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. */
588 struct lm_info_windows
: public lm_info_base
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 lm_info_windows
*li
= XCNEW (struct lm_info_windows
);
650 li
->load_addr
= load_addr
;
651 strcpy (so
->so_original_name
, name
);
653 strcpy (so
->so_name
, buf
);
656 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
657 SO_NAME_MAX_PATH_SIZE
);
660 char *rname
= realpath (name
, NULL
);
661 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
663 strcpy (so
->so_name
, rname
);
667 error (_("dll path too long"));
669 /* Record cygwin1.dll .text start/end. */
670 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
671 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
673 asection
*text
= NULL
;
676 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
681 if (bfd_check_format (abfd
.get (), bfd_object
))
682 text
= bfd_get_section_by_name (abfd
.get (), ".text");
687 /* The symbols in a dll are offset by 0x1000, which is the
688 offset from 0 of the first byte in an image - because of the
689 file header and the section alignment. */
690 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
692 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
701 get_image_name (HANDLE h
, void *address
, int unicode
)
704 static char buf
[__PMAX
];
706 static char buf
[(2 * __PMAX
) + 1];
708 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
714 /* Attempt to read the name of the dll that was detected.
715 This is documented to work only when actively debugging
716 a program. It will not work for attached processes. */
720 /* See if we could read the address of a string, and that the
721 address isn't null. */
722 if (!ReadProcessMemory (h
, address
, &address_ptr
,
723 sizeof (address_ptr
), &done
)
724 || done
!= sizeof (address_ptr
) || !address_ptr
)
727 /* Find the length of the string. */
728 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
729 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
733 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
736 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
737 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
740 wcstombs (buf
, unicode_address
, __PMAX
);
742 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
750 /* Handle a DLL load event, and return 1.
752 This function assumes that this event did not occur during inferior
753 initialization, where their event info may be incomplete (see
754 do_initial_windows_stuff and windows_add_all_dlls for more info
755 on how we handle DLL loading during that phase). */
758 handle_load_dll (void *dummy
)
760 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
763 /* Try getting the DLL name via the lpImageName field of the event.
764 Note that Microsoft documents this fields as strictly optional,
765 in the sense that it might be NULL. And the first DLL event in
766 particular is explicitly documented as "likely not pass[ed]"
767 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
768 dll_name
= get_image_name (current_process_handle
,
769 event
->lpImageName
, event
->fUnicode
);
773 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
774 solib_end
= solib_end
->next
;
776 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
778 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
779 host_address_to_string (li
->load_addr
)));
785 windows_free_so (struct so_list
*so
)
792 /* Handle a DLL unload event.
793 Return 1 if successful, or zero otherwise.
795 This function assumes that this event did not occur during inferior
796 initialization, where their event info may be incomplete (see
797 do_initial_windows_stuff and windows_add_all_dlls for more info
798 on how we handle DLL loading during that phase). */
801 handle_unload_dll (void *dummy
)
803 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
806 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
808 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
810 if (li_next
->load_addr
== lpBaseOfDll
)
812 struct so_list
*sodel
= so
->next
;
814 so
->next
= sodel
->next
;
817 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
819 windows_free_so (sodel
);
824 /* We did not find any DLL that was previously loaded at this address,
825 so register a complaint. We do not report an error, because we have
826 observed that this may be happening under some circumstances. For
827 instance, running 32bit applications on x64 Windows causes us to receive
828 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
829 events are apparently caused by the WOW layer, the interface between
830 32bit and 64bit worlds). */
831 complaint (&symfile_complaints
, _("dll starting at %s not found."),
832 host_address_to_string (lpBaseOfDll
));
837 /* Clear list of loaded DLLs. */
839 windows_clear_solib (void)
841 solib_start
.next
= NULL
;
842 solib_end
= &solib_start
;
846 signal_event_command (char *args
, int from_tty
)
848 uintptr_t event_id
= 0;
849 char *endargs
= NULL
;
852 error (_("signal-event requires an argument (integer event id)"));
854 event_id
= strtoumax (args
, &endargs
, 10);
856 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
857 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
858 error (_("Failed to convert `%s' to event id"), args
);
860 SetEvent ((HANDLE
) event_id
);
861 CloseHandle ((HANDLE
) event_id
);
864 /* Handle DEBUG_STRING output from child process.
865 Cygwin prepends its messages with a "cygwin:". Interpret this as
866 a Cygwin signal. Otherwise just print the string as a warning. */
868 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
873 if (!target_read_string
874 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
878 else if (!startswith (s
, _CYGWIN_SIGNAL_STRING
))
881 if (!startswith (s
, "cYg"))
884 char *p
= strchr (s
, '\0');
886 if (p
> s
&& *--p
== '\n')
894 /* Got a cygwin signal marker. A cygwin signal is followed by
895 the signal number itself and then optionally followed by the
896 thread id and address to saved context within the DLL. If
897 these are supplied, then the given thread is assumed to have
898 issued the signal and the context from the thread is assumed
899 to be stored at the given address in the inferior. Tell gdb
900 to treat this like a real signal. */
902 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
903 gdb_signal gotasig
= gdb_signal_from_host (sig
);
905 ourstatus
->value
.sig
= gotasig
;
911 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
912 retval
= strtoul (p
, &p
, 0);
914 retval
= main_thread_id
;
915 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
916 && ReadProcessMemory (current_process_handle
, x
,
918 __COPY_CONTEXT_SIZE
, &n
)
919 && n
== __COPY_CONTEXT_SIZE
)
920 have_saved_context
= 1;
931 display_selector (HANDLE thread
, DWORD sel
)
934 if (GetThreadSelectorEntry (thread
, sel
, &info
))
937 printf_filtered ("0x%03x: ", (unsigned) sel
);
938 if (!info
.HighWord
.Bits
.Pres
)
940 puts_filtered ("Segment not present\n");
943 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
944 (info
.HighWord
.Bits
.BaseMid
<< 16)
946 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
947 if (info
.HighWord
.Bits
.Granularity
)
948 limit
= (limit
<< 12) | 0xfff;
949 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
950 if (info
.HighWord
.Bits
.Default_Big
)
951 puts_filtered(" 32-bit ");
953 puts_filtered(" 16-bit ");
954 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
957 puts_filtered ("Data (Read-Only, Exp-up");
960 puts_filtered ("Data (Read/Write, Exp-up");
963 puts_filtered ("Unused segment (");
966 puts_filtered ("Data (Read/Write, Exp-down");
969 puts_filtered ("Code (Exec-Only, N.Conf");
972 puts_filtered ("Code (Exec/Read, N.Conf");
975 puts_filtered ("Code (Exec-Only, Conf");
978 puts_filtered ("Code (Exec/Read, Conf");
981 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
983 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
984 puts_filtered(", N.Acc");
985 puts_filtered (")\n");
986 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
987 puts_filtered("System selector ");
988 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
989 if (info
.HighWord
.Bits
.Granularity
)
990 puts_filtered ("Page granular.\n");
992 puts_filtered ("Byte granular.\n");
997 DWORD err
= GetLastError ();
998 if (err
== ERROR_NOT_SUPPORTED
)
999 printf_filtered ("Function not supported\n");
1001 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1007 display_selectors (char * args
, int from_tty
)
1009 if (!current_thread
)
1011 puts_filtered ("Impossible to display selectors now.\n");
1017 puts_filtered ("Selector $cs\n");
1018 display_selector (current_thread
->h
,
1019 current_thread
->context
.SegCs
);
1020 puts_filtered ("Selector $ds\n");
1021 display_selector (current_thread
->h
,
1022 current_thread
->context
.SegDs
);
1023 puts_filtered ("Selector $es\n");
1024 display_selector (current_thread
->h
,
1025 current_thread
->context
.SegEs
);
1026 puts_filtered ("Selector $ss\n");
1027 display_selector (current_thread
->h
,
1028 current_thread
->context
.SegSs
);
1029 puts_filtered ("Selector $fs\n");
1030 display_selector (current_thread
->h
,
1031 current_thread
->context
.SegFs
);
1032 puts_filtered ("Selector $gs\n");
1033 display_selector (current_thread
->h
,
1034 current_thread
->context
.SegGs
);
1039 sel
= parse_and_eval_long (args
);
1040 printf_filtered ("Selector \"%s\"\n",args
);
1041 display_selector (current_thread
->h
, sel
);
1045 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1046 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1047 host_address_to_string (\
1048 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1050 static handle_exception_result
1051 handle_exception (struct target_waitstatus
*ourstatus
)
1053 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1054 DWORD code
= rec
->ExceptionCode
;
1055 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1057 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1059 /* Record the context of the current thread. */
1060 thread_rec (current_event
.dwThreadId
, -1);
1064 case EXCEPTION_ACCESS_VIOLATION
:
1065 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1066 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1069 /* See if the access violation happened within the cygwin DLL
1070 itself. Cygwin uses a kind of exception handling to deal
1071 with passed-in invalid addresses. gdb should not treat
1072 these as real SEGVs since they will be silently handled by
1073 cygwin. A real SEGV will (theoretically) be caught by
1074 cygwin later in the process and will be sent as a
1075 cygwin-specific-signal. So, ignore SEGVs if they show up
1076 within the text segment of the DLL itself. */
1078 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1080 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1081 && addr
< cygwin_load_end
))
1082 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1083 && startswith (fn
, "KERNEL32!IsBad")))
1084 return HANDLE_EXCEPTION_UNHANDLED
;
1088 case STATUS_STACK_OVERFLOW
:
1089 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1090 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1092 case STATUS_FLOAT_DENORMAL_OPERAND
:
1093 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1094 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1096 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1097 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1098 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1100 case STATUS_FLOAT_INEXACT_RESULT
:
1101 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1102 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1104 case STATUS_FLOAT_INVALID_OPERATION
:
1105 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1106 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1108 case STATUS_FLOAT_OVERFLOW
:
1109 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1110 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1112 case STATUS_FLOAT_STACK_CHECK
:
1113 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1114 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1116 case STATUS_FLOAT_UNDERFLOW
:
1117 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1118 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1120 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1121 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1122 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1124 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1125 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1126 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1128 case STATUS_INTEGER_OVERFLOW
:
1129 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1130 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1132 case EXCEPTION_BREAKPOINT
:
1133 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1134 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1137 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1138 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1140 case DBG_CONTROL_BREAK
:
1141 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1142 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1144 case EXCEPTION_SINGLE_STEP
:
1145 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1146 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1148 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1149 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1150 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1152 case EXCEPTION_PRIV_INSTRUCTION
:
1153 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1154 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1156 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1157 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1158 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1160 case MS_VC_EXCEPTION
:
1161 if (rec
->NumberParameters
>= 3
1162 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1164 DWORD named_thread_id
;
1165 windows_thread_info
*named_thread
;
1166 CORE_ADDR thread_name_target
;
1168 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1170 thread_name_target
= rec
->ExceptionInformation
[1];
1171 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1173 if (named_thread_id
== (DWORD
) -1)
1174 named_thread_id
= current_event
.dwThreadId
;
1176 named_thread
= thread_rec (named_thread_id
, 0);
1177 if (named_thread
!= NULL
)
1179 int thread_name_len
;
1182 thread_name_len
= target_read_string (thread_name_target
,
1183 &thread_name
, 1025, NULL
);
1184 if (thread_name_len
> 0)
1186 thread_name
[thread_name_len
- 1] = '\0';
1187 xfree (named_thread
->name
);
1188 named_thread
->name
= thread_name
;
1191 xfree (thread_name
);
1193 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1194 result
= HANDLE_EXCEPTION_IGNORED
;
1197 /* treat improperly formed exception as unknown, fallthrough */
1199 /* Treat unhandled first chance exceptions specially. */
1200 if (current_event
.u
.Exception
.dwFirstChance
)
1201 return HANDLE_EXCEPTION_UNHANDLED
;
1202 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1203 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1204 host_address_to_string (
1205 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1206 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1210 last_sig
= ourstatus
->value
.sig
;
1214 /* Resume thread specified by ID, or all artificially suspended
1215 threads, if we are continuing execution. KILLED non-zero means we
1216 have killed the inferior, so we should ignore weird errors due to
1217 threads shutting down. */
1219 windows_continue (DWORD continue_status
, int id
, int killed
)
1222 windows_thread_info
*th
;
1225 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1226 (unsigned) current_event
.dwProcessId
,
1227 (unsigned) current_event
.dwThreadId
,
1228 continue_status
== DBG_CONTINUE
?
1229 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1231 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1232 if ((id
== -1 || id
== (int) th
->id
)
1235 if (debug_registers_changed
)
1237 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1238 th
->context
.Dr0
= dr
[0];
1239 th
->context
.Dr1
= dr
[1];
1240 th
->context
.Dr2
= dr
[2];
1241 th
->context
.Dr3
= dr
[3];
1242 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1243 th
->context
.Dr7
= dr
[7];
1245 if (th
->context
.ContextFlags
)
1249 if (GetExitCodeThread (th
->h
, &ec
)
1250 && ec
== STILL_ACTIVE
)
1252 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1257 th
->context
.ContextFlags
= 0;
1259 if (th
->suspended
> 0)
1260 (void) ResumeThread (th
->h
);
1264 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1265 current_event
.dwThreadId
,
1269 error (_("Failed to resume program execution"
1270 " (ContinueDebugEvent failed, error %u)"),
1271 (unsigned int) GetLastError ());
1273 debug_registers_changed
= 0;
1277 /* Called in pathological case where Windows fails to send a
1278 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1280 fake_create_process (void)
1282 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1283 current_event
.dwProcessId
);
1284 if (current_process_handle
!= NULL
)
1285 open_process_used
= 1;
1288 error (_("OpenProcess call failed, GetLastError = %u"),
1289 (unsigned) GetLastError ());
1290 /* We can not debug anything in that case. */
1292 main_thread_id
= current_event
.dwThreadId
;
1293 current_thread
= windows_add_thread (
1294 ptid_build (current_event
.dwProcessId
, 0,
1295 current_event
.dwThreadId
),
1296 current_event
.u
.CreateThread
.hThread
,
1297 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1298 return main_thread_id
;
1302 windows_resume (struct target_ops
*ops
,
1303 ptid_t ptid
, int step
, enum gdb_signal sig
)
1305 windows_thread_info
*th
;
1306 DWORD continue_status
= DBG_CONTINUE
;
1308 /* A specific PTID means `step only this thread id'. */
1309 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1311 /* If we're continuing all threads, it's the current inferior that
1312 should be handled specially. */
1314 ptid
= inferior_ptid
;
1316 if (sig
!= GDB_SIGNAL_0
)
1318 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1320 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1322 else if (sig
== last_sig
)
1323 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1326 /* This code does not seem to work, because
1327 the kernel does probably not consider changes in the ExceptionRecord
1328 structure when passing the exception to the inferior.
1329 Note that this seems possible in the exception handler itself. */
1332 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1333 if (xlate
[i
].us
== sig
)
1335 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1337 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1340 if (continue_status
== DBG_CONTINUE
)
1342 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1346 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1350 last_sig
= GDB_SIGNAL_0
;
1352 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1353 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1355 /* Get context for currently selected thread. */
1356 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1361 /* Single step by setting t bit. */
1362 struct regcache
*regcache
= get_current_regcache ();
1363 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1364 windows_fetch_inferior_registers (ops
, regcache
,
1365 gdbarch_ps_regnum (gdbarch
));
1366 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1369 if (th
->context
.ContextFlags
)
1371 if (debug_registers_changed
)
1373 th
->context
.Dr0
= dr
[0];
1374 th
->context
.Dr1
= dr
[1];
1375 th
->context
.Dr2
= dr
[2];
1376 th
->context
.Dr3
= dr
[3];
1377 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1378 th
->context
.Dr7
= dr
[7];
1380 CHECK (SetThreadContext (th
->h
, &th
->context
));
1381 th
->context
.ContextFlags
= 0;
1385 /* Allow continuing with the same signal that interrupted us.
1386 Otherwise complain. */
1389 windows_continue (continue_status
, -1, 0);
1391 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1394 /* Ctrl-C handler used when the inferior is not run in the same console. The
1395 handler is in charge of interrupting the inferior using DebugBreakProcess.
1396 Note that this function is not available prior to Windows XP. In this case
1397 we emit a warning. */
1399 ctrl_c_handler (DWORD event_type
)
1401 const int attach_flag
= current_inferior ()->attach_flag
;
1403 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1404 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1407 /* If the inferior and the debugger share the same console, do nothing as
1408 the inferior has also received the Ctrl-C event. */
1409 if (!new_console
&& !attach_flag
)
1412 if (!DebugBreakProcess (current_process_handle
))
1413 warning (_("Could not interrupt program. "
1414 "Press Ctrl-c in the program console."));
1416 /* Return true to tell that Ctrl-C has been handled. */
1420 /* Get the next event from the child. Returns a non-zero thread id if the event
1421 requires handling by WFI (or whatever). */
1423 get_windows_debug_event (struct target_ops
*ops
,
1424 int pid
, struct target_waitstatus
*ourstatus
)
1427 DWORD continue_status
, event_code
;
1428 windows_thread_info
*th
;
1429 static windows_thread_info dummy_thread_info
;
1430 DWORD thread_id
= 0;
1432 last_sig
= GDB_SIGNAL_0
;
1434 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1438 continue_status
= DBG_CONTINUE
;
1440 event_code
= current_event
.dwDebugEventCode
;
1441 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1443 have_saved_context
= 0;
1447 case CREATE_THREAD_DEBUG_EVENT
:
1448 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1449 (unsigned) current_event
.dwProcessId
,
1450 (unsigned) current_event
.dwThreadId
,
1451 "CREATE_THREAD_DEBUG_EVENT"));
1452 if (saw_create
!= 1)
1454 struct inferior
*inf
;
1455 inf
= find_inferior_pid (current_event
.dwProcessId
);
1456 if (!saw_create
&& inf
->attach_flag
)
1458 /* Kludge around a Windows bug where first event is a create
1459 thread event. Caused when attached process does not have
1461 thread_id
= fake_create_process ();
1467 /* Record the existence of this thread. */
1468 thread_id
= current_event
.dwThreadId
;
1469 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1470 current_event
.dwThreadId
),
1471 current_event
.u
.CreateThread
.hThread
,
1472 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1476 case EXIT_THREAD_DEBUG_EVENT
:
1477 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1478 (unsigned) current_event
.dwProcessId
,
1479 (unsigned) current_event
.dwThreadId
,
1480 "EXIT_THREAD_DEBUG_EVENT"));
1482 if (current_event
.dwThreadId
!= main_thread_id
)
1484 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1485 current_event
.dwThreadId
),
1486 current_event
.u
.ExitThread
.dwExitCode
);
1487 th
= &dummy_thread_info
;
1491 case CREATE_PROCESS_DEBUG_EVENT
:
1492 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1493 (unsigned) current_event
.dwProcessId
,
1494 (unsigned) current_event
.dwThreadId
,
1495 "CREATE_PROCESS_DEBUG_EVENT"));
1496 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1497 if (++saw_create
!= 1)
1500 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1502 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1505 main_thread_id
= current_event
.dwThreadId
;
1506 /* Add the main thread. */
1507 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1508 current_event
.dwThreadId
),
1509 current_event
.u
.CreateProcessInfo
.hThread
,
1510 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1511 thread_id
= current_event
.dwThreadId
;
1514 case EXIT_PROCESS_DEBUG_EVENT
:
1515 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1516 (unsigned) current_event
.dwProcessId
,
1517 (unsigned) current_event
.dwThreadId
,
1518 "EXIT_PROCESS_DEBUG_EVENT"));
1519 if (!windows_initialization_done
)
1521 target_terminal_ours ();
1522 target_mourn_inferior (inferior_ptid
);
1523 error (_("During startup program exited with code 0x%x."),
1524 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1526 else if (saw_create
== 1)
1528 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1529 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1530 thread_id
= main_thread_id
;
1534 case LOAD_DLL_DEBUG_EVENT
:
1535 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1536 (unsigned) current_event
.dwProcessId
,
1537 (unsigned) current_event
.dwThreadId
,
1538 "LOAD_DLL_DEBUG_EVENT"));
1539 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1540 if (saw_create
!= 1 || ! windows_initialization_done
)
1542 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1543 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1544 ourstatus
->value
.integer
= 0;
1545 thread_id
= main_thread_id
;
1548 case UNLOAD_DLL_DEBUG_EVENT
:
1549 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1550 (unsigned) current_event
.dwProcessId
,
1551 (unsigned) current_event
.dwThreadId
,
1552 "UNLOAD_DLL_DEBUG_EVENT"));
1553 if (saw_create
!= 1 || ! windows_initialization_done
)
1555 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1556 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1557 ourstatus
->value
.integer
= 0;
1558 thread_id
= main_thread_id
;
1561 case EXCEPTION_DEBUG_EVENT
:
1562 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1563 (unsigned) current_event
.dwProcessId
,
1564 (unsigned) current_event
.dwThreadId
,
1565 "EXCEPTION_DEBUG_EVENT"));
1566 if (saw_create
!= 1)
1568 switch (handle_exception (ourstatus
))
1570 case HANDLE_EXCEPTION_UNHANDLED
:
1572 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1574 case HANDLE_EXCEPTION_HANDLED
:
1575 thread_id
= current_event
.dwThreadId
;
1577 case HANDLE_EXCEPTION_IGNORED
:
1578 continue_status
= DBG_CONTINUE
;
1583 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1584 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1585 (unsigned) current_event
.dwProcessId
,
1586 (unsigned) current_event
.dwThreadId
,
1587 "OUTPUT_DEBUG_STRING_EVENT"));
1588 if (saw_create
!= 1)
1590 thread_id
= handle_output_debug_string (ourstatus
);
1594 if (saw_create
!= 1)
1596 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1597 (unsigned) current_event
.dwProcessId
,
1598 (unsigned) current_event
.dwThreadId
);
1599 printf_unfiltered (" unknown event code %u\n",
1600 (unsigned) current_event
.dwDebugEventCode
);
1604 if (!thread_id
|| saw_create
!= 1)
1606 CHECK (windows_continue (continue_status
, -1, 0));
1610 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1612 current_thread
= th
;
1613 if (!current_thread
)
1614 current_thread
= thread_rec (thread_id
, TRUE
);
1621 /* Wait for interesting events to occur in the target process. */
1623 windows_wait (struct target_ops
*ops
,
1624 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1628 target_terminal_ours ();
1630 /* We loop when we get a non-standard exception rather than return
1631 with a SPURIOUS because resume can try and step or modify things,
1632 which needs a current_thread->h. But some of these exceptions mark
1633 the birth or death of threads, which mean that the current thread
1634 isn't necessarily what you think it is. */
1640 /* If the user presses Ctrl-c while the debugger is waiting
1641 for an event, he expects the debugger to interrupt his program
1642 and to get the prompt back. There are two possible situations:
1644 - The debugger and the program do not share the console, in
1645 which case the Ctrl-c event only reached the debugger.
1646 In that case, the ctrl_c handler will take care of interrupting
1647 the inferior. Note that this case is working starting with
1648 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1651 - The debugger and the program share the same console, in which
1652 case both debugger and inferior will receive the Ctrl-c event.
1653 In that case the ctrl_c handler will ignore the event, as the
1654 Ctrl-c event generated inside the inferior will trigger the
1655 expected debug event.
1657 FIXME: brobecker/2008-05-20: If the inferior receives the
1658 signal first and the delay until GDB receives that signal
1659 is sufficiently long, GDB can sometimes receive the SIGINT
1660 after we have unblocked the CTRL+C handler. This would
1661 lead to the debugger stopping prematurely while handling
1662 the new-thread event that comes with the handling of the SIGINT
1663 inside the inferior, and then stop again immediately when
1664 the user tries to resume the execution in the inferior.
1665 This is a classic race that we should try to fix one day. */
1666 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1667 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1668 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1671 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1676 if (deprecated_ui_loop_hook
!= NULL
)
1677 detach
= deprecated_ui_loop_hook (0);
1680 windows_kill_inferior (ops
);
1685 /* Iterate over all DLLs currently mapped by our inferior, and
1686 add them to our list of solibs. */
1689 windows_add_all_dlls (void)
1692 HMODULE dummy_hmodule
;
1697 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1698 sizeof (HMODULE
), &cb_needed
) == 0)
1704 hmodules
= (HMODULE
*) alloca (cb_needed
);
1705 if (EnumProcessModules (current_process_handle
, hmodules
,
1706 cb_needed
, &cb_needed
) == 0)
1709 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1713 wchar_t dll_name
[__PMAX
];
1716 char dll_name
[__PMAX
];
1719 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1720 &mi
, sizeof (mi
)) == 0)
1722 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1723 dll_name
, sizeof (dll_name
)) == 0)
1726 wcstombs (name
, dll_name
, __PMAX
);
1731 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1732 solib_end
= solib_end
->next
;
1737 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1740 struct inferior
*inf
;
1741 struct thread_info
*tp
;
1743 last_sig
= GDB_SIGNAL_0
;
1745 exception_count
= 0;
1746 open_process_used
= 0;
1747 debug_registers_changed
= 0;
1748 debug_registers_used
= 0;
1749 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1752 cygwin_load_start
= cygwin_load_end
= 0;
1754 current_event
.dwProcessId
= pid
;
1755 memset (¤t_event
, 0, sizeof (current_event
));
1756 if (!target_is_pushed (ops
))
1758 disable_breakpoints_in_shlibs ();
1759 windows_clear_solib ();
1760 clear_proceed_status (0);
1761 init_wait_for_inferior ();
1763 inf
= current_inferior ();
1764 inferior_appeared (inf
, pid
);
1765 inf
->attach_flag
= attaching
;
1767 /* Make the new process the current inferior, so terminal handling
1768 can rely on it. When attaching, we don't know about any thread
1769 id here, but that's OK --- nothing should be referencing the
1770 current thread until we report an event out of windows_wait. */
1771 inferior_ptid
= pid_to_ptid (pid
);
1773 target_terminal_init ();
1774 target_terminal_inferior ();
1776 windows_initialization_done
= 0;
1780 struct target_waitstatus status
;
1782 windows_wait (ops
, minus_one_ptid
, &status
, 0);
1784 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1786 if (status
.kind
!= TARGET_WAITKIND_LOADED
1787 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1790 windows_resume (ops
, minus_one_ptid
, 0, GDB_SIGNAL_0
);
1793 /* Now that the inferior has been started and all DLLs have been mapped,
1794 we can iterate over all DLLs and load them in.
1796 We avoid doing it any earlier because, on certain versions of Windows,
1797 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1798 we have seen on Windows 8.1 that the ntdll.dll load event does not
1799 include the DLL name, preventing us from creating an associated SO.
1800 A possible explanation is that ntdll.dll might be mapped before
1801 the SO info gets created by the Windows system -- ntdll.dll is
1802 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1803 do not seem to suffer from that problem.
1805 Rather than try to work around this sort of issue, it is much
1806 simpler to just ignore DLL load/unload events during the startup
1807 phase, and then process them all in one batch now. */
1808 windows_add_all_dlls ();
1810 windows_initialization_done
= 1;
1814 /* Try to set or remove a user privilege to the current process. Return -1
1815 if that fails, the previous setting of that privilege otherwise.
1817 This code is copied from the Cygwin source code and rearranged to allow
1818 dynamically loading of the needed symbols from advapi32 which is only
1819 available on NT/2K/XP. */
1821 set_process_privilege (const char *privilege
, BOOL enable
)
1823 HANDLE token_hdl
= NULL
;
1825 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1829 if (!OpenProcessToken (GetCurrentProcess (),
1830 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1834 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1837 new_priv
.PrivilegeCount
= 1;
1838 new_priv
.Privileges
[0].Luid
= restore_priv
;
1839 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1841 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1842 sizeof orig_priv
, &orig_priv
, &size
))
1845 /* Disabled, otherwise every `attach' in an unprivileged user session
1846 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1847 windows_attach(). */
1848 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1849 be enabled. GetLastError () returns an correct error code, though. */
1850 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1854 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1858 CloseHandle (token_hdl
);
1863 /* Attach to process PID, then initialize for debugging it. */
1865 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1870 pid
= parse_pid_to_attach (args
);
1872 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1874 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1875 printf_unfiltered ("This can cause attach to "
1876 "fail on Windows NT/2K/XP\n");
1879 windows_init_thread_list ();
1880 ok
= DebugActiveProcess (pid
);
1886 /* Try fall back to Cygwin pid. */
1887 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1890 ok
= DebugActiveProcess (pid
);
1895 error (_("Can't attach to process."));
1897 DebugSetProcessKillOnExit (FALSE
);
1901 char *exec_file
= (char *) get_exec_file (0);
1904 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1905 target_pid_to_str (pid_to_ptid (pid
)));
1907 printf_unfiltered ("Attaching to %s\n",
1908 target_pid_to_str (pid_to_ptid (pid
)));
1910 gdb_flush (gdb_stdout
);
1913 do_initial_windows_stuff (ops
, pid
, 1);
1914 target_terminal_ours ();
1918 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1922 ptid_t ptid
= minus_one_ptid
;
1923 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1925 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1927 error (_("Can't detach process %u (error %u)"),
1928 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1931 DebugSetProcessKillOnExit (FALSE
);
1933 if (detached
&& from_tty
)
1935 const char *exec_file
= get_exec_file (0);
1938 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1939 (unsigned) current_event
.dwProcessId
);
1940 gdb_flush (gdb_stdout
);
1943 x86_cleanup_dregs ();
1944 inferior_ptid
= null_ptid
;
1945 detach_inferior (current_event
.dwProcessId
);
1947 inf_child_maybe_unpush_target (ops
);
1950 /* Try to determine the executable filename.
1952 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1954 Upon success, the filename is stored inside EXE_NAME_RET, and
1955 this function returns nonzero.
1957 Otherwise, this function returns zero and the contents of
1958 EXE_NAME_RET is undefined. */
1961 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1968 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1969 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1972 /* We know the executable is always first in the list of modules,
1973 which we just fetched. So no need to fetch more. */
1977 /* Cygwin prefers that the path be in /x/y/z format, so extract
1978 the filename into a temporary buffer first, and then convert it
1979 to POSIX format into the destination buffer. */
1980 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1982 len
= GetModuleFileNameEx (current_process_handle
,
1983 dh_buf
, pathbuf
, exe_name_max_len
);
1985 error (_("Error getting executable filename: %u."),
1986 (unsigned) GetLastError ());
1987 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1988 exe_name_max_len
) < 0)
1989 error (_("Error converting executable filename to POSIX: %d."), errno
);
1992 len
= GetModuleFileNameEx (current_process_handle
,
1993 dh_buf
, exe_name_ret
, exe_name_max_len
);
1995 error (_("Error getting executable filename: %u."),
1996 (unsigned) GetLastError ());
1999 return 1; /* success */
2002 /* The pid_to_exec_file target_ops method for this platform. */
2005 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
2007 static char path
[__PMAX
];
2009 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2011 char procexe
[sizeof ("/proc/4294967295/exe")];
2013 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2014 nchars
= readlink (procexe
, path
, sizeof(path
));
2015 if (nchars
> 0 && nchars
< sizeof (path
))
2017 path
[nchars
] = '\0'; /* Got it */
2022 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2023 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2024 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2030 /* Print status information about what we're accessing. */
2033 windows_files_info (struct target_ops
*ignore
)
2035 struct inferior
*inf
= current_inferior ();
2037 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2038 inf
->attach_flag
? "attached" : "child",
2039 target_pid_to_str (inferior_ptid
));
2042 /* Modify CreateProcess parameters for use of a new separate console.
2044 *FLAGS: DWORD parameter for general process creation flags.
2045 *SI: STARTUPINFO structure, for which the console window size and
2046 console buffer size is filled in if GDB is running in a console.
2047 to create the new console.
2048 The size of the used font is not available on all versions of
2049 Windows OS. Furthermore, the current font might not be the default
2050 font, but this is still better than before.
2051 If the windows and buffer sizes are computed,
2052 SI->DWFLAGS is changed so that this information is used
2053 by CreateProcess function. */
2056 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2058 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2059 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2061 if (hconsole
!= INVALID_HANDLE_VALUE
)
2063 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2065 CONSOLE_FONT_INFO cfi
;
2067 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2068 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2069 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2070 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2071 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2073 si
->dwXSize
*= font_size
.X
;
2077 si
->dwYSize
*= font_size
.Y
;
2080 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2081 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2082 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2084 *flags
|= CREATE_NEW_CONSOLE
;
2088 /* Function called by qsort to sort environment strings. */
2091 envvar_cmp (const void *a
, const void *b
)
2093 const char **p
= (const char **) a
;
2094 const char **q
= (const char **) b
;
2095 return strcasecmp (*p
, *q
);
2101 clear_win32_environment (char **env
)
2105 wchar_t *copy
= NULL
, *equalpos
;
2107 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2109 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2110 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2111 mbstowcs (copy
, env
[i
], len
);
2112 equalpos
= wcschr (copy
, L
'=');
2115 SetEnvironmentVariableW (copy
, NULL
);
2123 /* Redirection of inferior I/O streams for native MS-Windows programs.
2124 Unlike on Unix, where this is handled by invoking the inferior via
2125 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2127 The official documentation of the cmd.exe redirection features is here:
2129 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2131 (That page talks about Windows XP, but there's no newer
2132 documentation, so we assume later versions of cmd.exe didn't change
2135 Caveat: the documentation on that page seems to include a few lies.
2136 For example, it describes strange constructs 1<&2 and 2<&1, which
2137 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2138 think the cmd.exe parser of the redirection symbols simply doesn't
2139 care about the < vs > distinction in these cases. Therefore, the
2140 supported features are explicitly documented below.
2142 The emulation below aims at supporting all the valid use cases
2143 supported by cmd.exe, which include:
2145 < FILE redirect standard input from FILE
2146 0< FILE redirect standard input from FILE
2147 <&N redirect standard input from file descriptor N
2148 0<&N redirect standard input from file descriptor N
2149 > FILE redirect standard output to FILE
2150 >> FILE append standard output to FILE
2151 1>> FILE append standard output to FILE
2152 >&N redirect standard output to file descriptor N
2153 1>&N redirect standard output to file descriptor N
2154 >>&N append standard output to file descriptor N
2155 1>>&N append standard output to file descriptor N
2156 2> FILE redirect standard error to FILE
2157 2>> FILE append standard error to FILE
2158 2>&N redirect standard error to file descriptor N
2159 2>>&N append standard error to file descriptor N
2161 Note that using N > 2 in the above construct is supported, but
2162 requires that the corresponding file descriptor be open by some
2163 means elsewhere or outside GDB. Also note that using ">&0" or
2164 "<&2" will generally fail, because the file descriptor redirected
2165 from is normally open in an incompatible mode (e.g., FD 0 is open
2166 for reading only). IOW, use of such tricks is not recommended;
2167 you are on your own.
2169 We do NOT support redirection of file descriptors above 2, as in
2170 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2171 that needs special handling in the startup code that MinGW
2172 doesn't have). Pipes are also not supported.
2174 As for invalid use cases, where the redirection contains some
2175 error, the emulation below will detect that and produce some
2176 error and/or failure. But the behavior in those cases is not
2177 bug-for-bug compatible with what cmd.exe does in those cases.
2178 That's because what cmd.exe does then is not well defined, and
2179 seems to be a side effect of the cmd.exe parsing of the command
2180 line more than anything else. For example, try redirecting to an
2181 invalid file name, as in "> foo:bar".
2183 There are also minor syntactic deviations from what cmd.exe does
2184 in some corner cases. For example, it doesn't support the likes
2185 of "> &foo" to mean redirect to file named literally "&foo"; we
2186 do support that here, because that, too, sounds like some issue
2187 with the cmd.exe parser. Another nicety is that we support
2188 redirection targets that use file names with forward slashes,
2189 something cmd.exe doesn't -- this comes in handy since GDB
2190 file-name completion can be used when typing the command line for
2193 /* Support routines for redirecting standard handles of the inferior. */
2195 /* Parse a single redirection spec, open/duplicate the specified
2196 file/fd, and assign the appropriate value to one of the 3 standard
2197 file descriptors. */
2199 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2201 int *fd
, ref_fd
= -2;
2203 const char *fname
= redir_string
+ 1;
2204 int rc
= *redir_string
;
2219 fd
= (rc
== '2') ? err
: out
;
2220 mode
= O_WRONLY
| O_CREAT
;
2233 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2235 /* A reference to a file descriptor. */
2237 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2238 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2240 /* Don't allow redirection when open modes are incompatible. */
2241 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2242 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2249 else if (ref_fd
== 1)
2251 else if (ref_fd
== 2)
2261 fname
++; /* skip the separator space */
2262 /* If the descriptor is already open, close it. This allows
2263 multiple specs of redirections for the same stream, which is
2264 somewhat nonsensical, but still valid and supported by cmd.exe.
2265 (But cmd.exe only opens a single file in this case, the one
2266 specified by the last redirection spec on the command line.) */
2271 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2275 else if (ref_fd
== -1)
2276 *fd
= -1; /* reset to default destination */
2279 *fd
= _dup (ref_fd
);
2283 /* _open just sets a flag for O_APPEND, which won't be passed to the
2284 inferior, so we need to actually move the file pointer. */
2285 if ((mode
& O_APPEND
) != 0)
2286 _lseek (*fd
, 0L, SEEK_END
);
2290 /* Canonicalize a single redirection spec and set up the corresponding
2291 file descriptor as specified. */
2293 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2295 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2297 const char *start
= s
;
2300 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2301 if ((*start
== '>' || *start
== '1' || *start
== '2')
2305 if (*s
== '>' && *start
!= '>')
2308 else if (*start
== '0' && *s
== '<')
2310 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2313 while (isspace (*s
)) /* skip whitespace before file name */
2315 *d
++ = ' '; /* separate file name with a single space */
2318 /* Copy the file name. */
2321 /* Remove quoting characters from the file name in buf[]. */
2322 if (*s
== '"') /* could support '..' quoting here */
2326 else if (*s
== quote
)
2334 else if (*s
== '\\')
2336 if (s
[1] == '"') /* could support '..' here */
2340 else if (isspace (*s
) && !quote
)
2344 if (d
- buf
>= sizeof (buf
) - 1)
2346 errno
= ENAMETOOLONG
;
2352 /* Windows doesn't allow redirection characters in file names, so we
2353 can bail out early if they use them, or if there's no target file
2354 name after the redirection symbol. */
2355 if (d
[-1] == '>' || d
[-1] == '<')
2360 if (redir_open (buf
, inp
, out
, err
) == 0)
2365 /* Parse the command line for redirection specs and prepare the file
2366 descriptors for the 3 standard streams accordingly. */
2368 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2369 int *inp
, int *out
, int *err
)
2371 const char *s
= cmd_orig
;
2374 bool retval
= false;
2376 while (isspace (*s
))
2381 if (*s
== '"') /* could also support '..' quoting here */
2385 else if (*s
== quote
)
2388 else if (*s
== '\\')
2390 if (s
[1] == '"') /* escaped quote char */
2395 /* Process a single redirection candidate. */
2396 if (*s
== '<' || *s
== '>'
2397 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2398 || (*s
== '0' && s
[1] == '<'))
2400 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2414 #endif /* !__CYGWIN__ */
2416 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2417 EXEC_FILE is the file to run.
2418 ALLARGS is a string containing the arguments to the program.
2419 ENV is the environment vector to pass. Errors reported with error(). */
2422 windows_create_inferior (struct target_ops
*ops
, const char *exec_file
,
2423 const std::string
&origallargs
, char **in_env
,
2428 cygwin_buf_t real_path
[__PMAX
];
2429 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2431 cygwin_buf_t
*toexec
;
2432 cygwin_buf_t
*cygallargs
;
2434 char **old_env
= NULL
;
2438 int ostdin
, ostdout
, ostderr
;
2439 #else /* !__CYGWIN__ */
2440 char real_path
[__PMAX
];
2441 char shell
[__PMAX
]; /* Path to shell */
2443 char *args
, *allargs_copy
;
2444 size_t args_len
, allargs_len
;
2445 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2446 HANDLE tty
= INVALID_HANDLE_VALUE
;
2447 HANDLE inf_stdin
= INVALID_HANDLE_VALUE
;
2448 HANDLE inf_stdout
= INVALID_HANDLE_VALUE
;
2449 HANDLE inf_stderr
= INVALID_HANDLE_VALUE
;
2450 bool redirected
= false;
2457 #endif /* !__CYGWIN__ */
2458 const char *allargs
= origallargs
.c_str ();
2459 PROCESS_INFORMATION pi
;
2462 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2465 error (_("No executable specified, use `target exec'."));
2467 memset (&si
, 0, sizeof (si
));
2468 si
.cb
= sizeof (si
);
2471 flags
|= CREATE_NEW_PROCESS_GROUP
;
2474 windows_set_console_info (&si
, &flags
);
2479 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2480 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2481 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2482 error (_("Error starting executable: %d"), errno
);
2485 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2486 if (len
== (size_t) -1)
2487 error (_("Error starting executable: %d"), errno
);
2488 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2489 mbstowcs (cygallargs
, allargs
, len
);
2490 #else /* !__USEWIDE */
2491 cygallargs
= allargs
;
2496 sh
= getenv ("SHELL");
2499 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2500 error (_("Error starting executable via shell: %d"), errno
);
2502 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2503 + mbstowcs (NULL
, allargs
, 0) + 2;
2504 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2505 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2506 #else /* !__USEWIDE */
2507 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2508 + strlen (allargs
) + 2);
2509 cygallargs
= (char *) alloca (len
);
2510 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2511 #endif /* __USEWIDE */
2513 flags
|= DEBUG_PROCESS
;
2517 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2518 * sizeof (wchar_t));
2519 wcscpy (args
, toexec
);
2520 wcscat (args
, L
" ");
2521 wcscat (args
, cygallargs
);
2522 #else /* !__USEWIDE */
2523 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2524 strcpy (args
, toexec
);
2526 strcat (args
, cygallargs
);
2527 #endif /* !__USEWIDE */
2529 #ifdef CW_CVT_ENV_TO_WINENV
2530 /* First try to create a direct Win32 copy of the POSIX environment. */
2531 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2532 if (w32_env
!= (PWCHAR
) -1)
2533 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2535 /* If that fails, fall back to old method tweaking GDB's environment. */
2536 #endif /* CW_CVT_ENV_TO_WINENV */
2538 /* Reset all Win32 environment variables to avoid leftover on next run. */
2539 clear_win32_environment (environ
);
2540 /* Prepare the environment vars for CreateProcess. */
2543 cygwin_internal (CW_SYNC_WINENV
);
2547 if (!inferior_io_terminal
)
2548 tty
= ostdin
= ostdout
= ostderr
= -1;
2551 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2554 print_sys_errmsg (inferior_io_terminal
, errno
);
2555 ostdin
= ostdout
= ostderr
= -1;
2568 windows_init_thread_list ();
2569 ret
= CreateProcess (0,
2570 args
, /* command line */
2571 NULL
, /* Security */
2573 TRUE
, /* inherit handles */
2574 flags
, /* start flags */
2575 w32_env
, /* environment */
2576 NULL
, /* current directory */
2580 /* Just free the Win32 environment, if it could be created. */
2584 /* Reset all environment variables to avoid leftover on next run. */
2585 clear_win32_environment (in_env
);
2586 /* Restore normal GDB environment variables. */
2588 cygwin_internal (CW_SYNC_WINENV
);
2601 #else /* !__CYGWIN__ */
2602 allargs_len
= strlen (allargs
);
2603 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2604 if (strpbrk (allargs_copy
, "<>") != NULL
)
2609 redirect_inferior_handles (allargs
, allargs_copy
,
2610 &fd_inp
, &fd_out
, &fd_err
);
2612 warning (_("Error in redirection: %s."), strerror (errno
));
2615 allargs_len
= strlen (allargs_copy
);
2617 /* If not all the standard streams are redirected by the command
2618 line, use inferior_io_terminal for those which aren't. */
2619 if (inferior_io_terminal
2620 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2622 SECURITY_ATTRIBUTES sa
;
2623 sa
.nLength
= sizeof(sa
);
2624 sa
.lpSecurityDescriptor
= 0;
2625 sa
.bInheritHandle
= TRUE
;
2626 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2627 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2628 if (tty
== INVALID_HANDLE_VALUE
)
2629 warning (_("Warning: Failed to open TTY %s, error %#x."),
2630 inferior_io_terminal
, (unsigned) GetLastError ());
2632 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2635 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2636 else if (tty
!= INVALID_HANDLE_VALUE
)
2639 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2641 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2642 else if (tty
!= INVALID_HANDLE_VALUE
)
2643 si
.hStdOutput
= tty
;
2645 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2647 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2648 else if (tty
!= INVALID_HANDLE_VALUE
)
2651 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2652 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2656 /* Build the command line, a space-separated list of tokens where
2657 the first token is the name of the module to be executed.
2658 To avoid ambiguities introduced by spaces in the module name,
2660 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2661 args
= (char *) alloca (args_len
);
2662 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2664 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2666 /* CreateProcess takes the environment list as a null terminated set of
2667 strings (i.e. two nulls terminate the list). */
2669 /* Get total size for env strings. */
2670 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2671 envlen
+= strlen (in_env
[i
]) + 1;
2673 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2674 env
= (char **) alloca (envsize
);
2675 memcpy (env
, in_env
, envsize
);
2676 /* Windows programs expect the environment block to be sorted. */
2677 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2679 w32env
= (char *) alloca (envlen
+ 1);
2681 /* Copy env strings into new buffer. */
2682 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2684 strcpy (temp
, env
[i
]);
2685 temp
+= strlen (temp
) + 1;
2688 /* Final nil string to terminate new env. */
2691 windows_init_thread_list ();
2692 ret
= CreateProcessA (0,
2693 args
, /* command line */
2694 NULL
, /* Security */
2696 TRUE
, /* inherit handles */
2697 flags
, /* start flags */
2698 w32env
, /* environment */
2699 NULL
, /* current directory */
2702 if (tty
!= INVALID_HANDLE_VALUE
)
2710 #endif /* !__CYGWIN__ */
2713 error (_("Error creating process %s, (error %u)."),
2714 exec_file
, (unsigned) GetLastError ());
2716 CloseHandle (pi
.hThread
);
2717 CloseHandle (pi
.hProcess
);
2719 if (useshell
&& shell
[0] != '\0')
2724 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2726 /* windows_continue (DBG_CONTINUE, -1, 0); */
2730 windows_mourn_inferior (struct target_ops
*ops
)
2732 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2733 x86_cleanup_dregs();
2734 if (open_process_used
)
2736 CHECK (CloseHandle (current_process_handle
));
2737 open_process_used
= 0;
2739 inf_child_mourn_inferior (ops
);
2742 /* Send a SIGINT to the process group. This acts just like the user typed a
2743 ^C on the controlling terminal. */
2746 windows_interrupt (struct target_ops
*self
, ptid_t ptid
)
2748 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2749 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2750 registers_changed (); /* refresh register state */
2753 /* Helper for windows_xfer_partial that handles memory transfers.
2754 Arguments are like target_xfer_partial. */
2756 static enum target_xfer_status
2757 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2758 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2762 DWORD lasterror
= 0;
2764 if (writebuf
!= NULL
)
2766 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2767 pulongest (len
), core_addr_to_string (memaddr
)));
2768 success
= WriteProcessMemory (current_process_handle
,
2769 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2772 lasterror
= GetLastError ();
2773 FlushInstructionCache (current_process_handle
,
2774 (LPCVOID
) (uintptr_t) memaddr
, len
);
2778 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2779 pulongest (len
), core_addr_to_string (memaddr
)));
2780 success
= ReadProcessMemory (current_process_handle
,
2781 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2784 lasterror
= GetLastError ();
2786 *xfered_len
= (ULONGEST
) done
;
2787 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2788 return TARGET_XFER_OK
;
2790 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2794 windows_kill_inferior (struct target_ops
*ops
)
2796 CHECK (TerminateProcess (current_process_handle
, 0));
2800 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2802 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2804 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2808 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2812 windows_close (struct target_ops
*self
)
2814 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2815 ptid_get_pid (inferior_ptid
)));
2818 /* Convert pid to printable format. */
2820 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2822 static char buf
[80];
2824 if (ptid_get_tid (ptid
) != 0)
2826 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2827 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2831 return normal_pid_to_str (ptid
);
2834 static enum target_xfer_status
2835 windows_xfer_shared_libraries (struct target_ops
*ops
,
2836 enum target_object object
, const char *annex
,
2837 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2838 ULONGEST offset
, ULONGEST len
,
2839 ULONGEST
*xfered_len
)
2841 struct obstack obstack
;
2847 return TARGET_XFER_E_IO
;
2849 obstack_init (&obstack
);
2850 obstack_grow_str (&obstack
, "<library-list>\n");
2851 for (so
= solib_start
.next
; so
; so
= so
->next
)
2853 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2855 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2856 (uintptr_t) li
->load_addr
,
2857 target_gdbarch (), &obstack
);
2859 obstack_grow_str0 (&obstack
, "</library-list>\n");
2861 buf
= (const char *) obstack_finish (&obstack
);
2862 len_avail
= strlen (buf
);
2863 if (offset
>= len_avail
)
2867 if (len
> len_avail
- offset
)
2868 len
= len_avail
- offset
;
2869 memcpy (readbuf
, buf
+ offset
, len
);
2872 obstack_free (&obstack
, NULL
);
2873 *xfered_len
= (ULONGEST
) len
;
2874 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2877 static enum target_xfer_status
2878 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2879 const char *annex
, gdb_byte
*readbuf
,
2880 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2881 ULONGEST
*xfered_len
)
2885 case TARGET_OBJECT_MEMORY
:
2886 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2888 case TARGET_OBJECT_LIBRARIES
:
2889 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2890 writebuf
, offset
, len
, xfered_len
);
2893 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2894 readbuf
, writebuf
, offset
, len
,
2899 /* Provide thread local base, i.e. Thread Information Block address.
2900 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2903 windows_get_tib_address (struct target_ops
*self
,
2904 ptid_t ptid
, CORE_ADDR
*addr
)
2906 windows_thread_info
*th
;
2908 th
= thread_rec (ptid_get_tid (ptid
), 0);
2913 *addr
= th
->thread_local_base
;
2919 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2921 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2924 /* Implementation of the to_thread_name method. */
2927 windows_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
2929 return thread_rec (ptid_get_tid (thr
->ptid
), 0)->name
;
2932 static struct target_ops
*
2933 windows_target (void)
2935 struct target_ops
*t
= inf_child_target ();
2937 t
->to_close
= windows_close
;
2938 t
->to_attach
= windows_attach
;
2939 t
->to_attach_no_wait
= 1;
2940 t
->to_detach
= windows_detach
;
2941 t
->to_resume
= windows_resume
;
2942 t
->to_wait
= windows_wait
;
2943 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2944 t
->to_store_registers
= windows_store_inferior_registers
;
2945 t
->to_xfer_partial
= windows_xfer_partial
;
2946 t
->to_files_info
= windows_files_info
;
2947 t
->to_kill
= windows_kill_inferior
;
2948 t
->to_create_inferior
= windows_create_inferior
;
2949 t
->to_mourn_inferior
= windows_mourn_inferior
;
2950 t
->to_thread_alive
= windows_thread_alive
;
2951 t
->to_pid_to_str
= windows_pid_to_str
;
2952 t
->to_interrupt
= windows_interrupt
;
2953 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2954 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2955 t
->to_get_tib_address
= windows_get_tib_address
;
2956 t
->to_thread_name
= windows_thread_name
;
2961 /* -Wmissing-prototypes */
2962 extern initialize_file_ftype _initialize_windows_nat
;
2965 _initialize_windows_nat (void)
2967 struct target_ops
*t
;
2969 t
= windows_target ();
2971 x86_use_watchpoints (t
);
2973 x86_dr_low
.set_control
= cygwin_set_dr7
;
2974 x86_dr_low
.set_addr
= cygwin_set_dr
;
2975 x86_dr_low
.get_addr
= cygwin_get_dr
;
2976 x86_dr_low
.get_status
= cygwin_get_dr6
;
2977 x86_dr_low
.get_control
= cygwin_get_dr7
;
2979 /* x86_dr_low.debug_register_length field is set by
2980 calling x86_set_debug_register_length function
2981 in processor windows specific native file. */
2986 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2989 add_com ("signal-event", class_run
, signal_event_command
, _("\
2990 Signal a crashed process with event ID, to allow its debugging.\n\
2991 This command is needed in support of setting up GDB as JIT debugger on \
2992 MS-Windows. The command should be invoked from the GDB command line using \
2993 the '-ex' command-line option. The ID of the event that blocks the \
2994 crashed process will be supplied by the Windows JIT debugging mechanism."));
2997 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2998 Set use of shell to start subprocess."), _("\
2999 Show use of shell to start subprocess."), NULL
,
3001 NULL
, /* FIXME: i18n: */
3002 &setlist
, &showlist
);
3004 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3005 &cygwin_exceptions
, _("\
3006 Break when an exception is detected in the Cygwin DLL itself."), _("\
3007 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3009 NULL
, /* FIXME: i18n: */
3010 &setlist
, &showlist
);
3013 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3014 Set creation of new console when creating child process."), _("\
3015 Show creation of new console when creating child process."), NULL
,
3017 NULL
, /* FIXME: i18n: */
3018 &setlist
, &showlist
);
3020 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3021 Set creation of new group when creating child process."), _("\
3022 Show creation of new group when creating child process."), NULL
,
3024 NULL
, /* FIXME: i18n: */
3025 &setlist
, &showlist
);
3027 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3028 Set whether to display execution in child process."), _("\
3029 Show whether to display execution in child process."), NULL
,
3031 NULL
, /* FIXME: i18n: */
3032 &setlist
, &showlist
);
3034 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3035 Set whether to display kernel events in child process."), _("\
3036 Show whether to display kernel events in child process."), NULL
,
3038 NULL
, /* FIXME: i18n: */
3039 &setlist
, &showlist
);
3041 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3042 Set whether to display memory accesses in child process."), _("\
3043 Show whether to display memory accesses in child process."), NULL
,
3045 NULL
, /* FIXME: i18n: */
3046 &setlist
, &showlist
);
3048 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3049 &debug_exceptions
, _("\
3050 Set whether to display kernel exceptions in child process."), _("\
3051 Show whether to display kernel exceptions in child process."), NULL
,
3053 NULL
, /* FIXME: i18n: */
3054 &setlist
, &showlist
);
3056 init_w32_command_list ();
3058 add_cmd ("selector", class_info
, display_selectors
,
3059 _("Display selectors infos."),
3063 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3065 /* Pass the address ADDR to the inferior in the I'th debug register.
3066 Here we just store the address in dr array, the registers will be
3067 actually set up when windows_continue is called. */
3069 cygwin_set_dr (int i
, CORE_ADDR addr
)
3072 internal_error (__FILE__
, __LINE__
,
3073 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3075 debug_registers_changed
= 1;
3076 debug_registers_used
= 1;
3079 /* Pass the value VAL to the inferior in the DR7 debug control
3080 register. Here we just store the address in D_REGS, the watchpoint
3081 will be actually set up in windows_wait. */
3083 cygwin_set_dr7 (unsigned long val
)
3085 dr
[7] = (CORE_ADDR
) val
;
3086 debug_registers_changed
= 1;
3087 debug_registers_used
= 1;
3090 /* Get the value of debug register I from the inferior. */
3093 cygwin_get_dr (int i
)
3098 /* Get the value of the DR6 debug status register from the inferior.
3099 Here we just return the value stored in dr[6]
3100 by the last call to thread_rec for current_event.dwThreadId id. */
3101 static unsigned long
3102 cygwin_get_dr6 (void)
3104 return (unsigned long) dr
[6];
3107 /* Get the value of the DR7 debug status register from the inferior.
3108 Here we just return the value stored in dr[7] by the last call to
3109 thread_rec for current_event.dwThreadId id. */
3111 static unsigned long
3112 cygwin_get_dr7 (void)
3114 return (unsigned long) dr
[7];
3117 /* Determine if the thread referenced by "ptid" is alive
3118 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3119 it means that the thread has died. Otherwise it is assumed to be alive. */
3121 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3125 gdb_assert (ptid_get_tid (ptid
) != 0);
3126 tid
= ptid_get_tid (ptid
);
3128 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
3132 /* -Wmissing-prototypes */
3133 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
3136 _initialize_check_for_gdb_ini (void)
3139 if (inhibit_gdbinit
)
3142 homedir
= getenv ("HOME");
3146 char *oldini
= (char *) alloca (strlen (homedir
) +
3147 sizeof ("gdb.ini") + 1);
3148 strcpy (oldini
, homedir
);
3149 p
= strchr (oldini
, '\0');
3150 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3152 strcpy (p
, "gdb.ini");
3153 if (access (oldini
, 0) == 0)
3155 int len
= strlen (oldini
);
3156 char *newini
= (char *) alloca (len
+ 2);
3158 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3159 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3160 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3165 /* Define dummy functions which always return error for the rare cases where
3166 these functions could not be found. */
3168 bad_DebugActiveProcessStop (DWORD w
)
3173 bad_DebugBreakProcess (HANDLE w
)
3178 bad_DebugSetProcessKillOnExit (BOOL w
)
3183 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3190 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3196 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3203 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3209 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3215 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3221 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3229 /* -Wmissing-prototypes */
3230 extern initialize_file_ftype _initialize_loadable
;
3232 /* Load any functions which may not be available in ancient versions
3236 _initialize_loadable (void)
3240 #define GPA(m, func) \
3241 func = (func ## _ftype *) GetProcAddress (m, #func)
3243 hm
= LoadLibrary ("kernel32.dll");
3246 GPA (hm
, DebugActiveProcessStop
);
3247 GPA (hm
, DebugBreakProcess
);
3248 GPA (hm
, DebugSetProcessKillOnExit
);
3249 GPA (hm
, GetConsoleFontSize
);
3250 GPA (hm
, DebugActiveProcessStop
);
3251 GPA (hm
, GetCurrentConsoleFont
);
3254 /* Set variables to dummy versions of these processes if the function
3255 wasn't found in kernel32.dll. */
3256 if (!DebugBreakProcess
)
3257 DebugBreakProcess
= bad_DebugBreakProcess
;
3258 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3260 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3261 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3263 if (!GetConsoleFontSize
)
3264 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3265 if (!GetCurrentConsoleFont
)
3266 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3268 /* Load optional functions used for retrieving filename information
3269 associated with the currently debugged process or its dlls. */
3270 hm
= LoadLibrary ("psapi.dll");
3273 GPA (hm
, EnumProcessModules
);
3274 GPA (hm
, GetModuleInformation
);
3275 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3276 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3279 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3281 /* Set variables to dummy versions of these processes if the function
3282 wasn't found in psapi.dll. */
3283 EnumProcessModules
= bad_EnumProcessModules
;
3284 GetModuleInformation
= bad_GetModuleInformation
;
3285 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3286 /* This will probably fail on Windows 9x/Me. Let the user know
3287 that we're missing some functionality. */
3289 cannot automatically find executable file or library to read symbols.\n\
3290 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3293 hm
= LoadLibrary ("advapi32.dll");
3296 GPA (hm
, OpenProcessToken
);
3297 GPA (hm
, LookupPrivilegeValueA
);
3298 GPA (hm
, AdjustTokenPrivileges
);
3299 /* Only need to set one of these since if OpenProcessToken fails nothing
3301 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3302 || !AdjustTokenPrivileges
)
3303 OpenProcessToken
= bad_OpenProcessToken
;