1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2018 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>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdb_tilde_expand.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
85 DWORD
, PTOKEN_PRIVILEGES
,
87 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
89 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
90 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
92 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
93 static DebugBreakProcess_ftype
*DebugBreakProcess
;
95 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
96 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
98 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
100 static EnumProcessModules_ftype
*EnumProcessModules
;
102 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
103 LPMODULEINFO
, DWORD
);
104 static GetModuleInformation_ftype
*GetModuleInformation
;
106 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
107 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
109 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
110 static OpenProcessToken_ftype
*OpenProcessToken
;
112 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
113 CONSOLE_FONT_INFO
*);
114 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
116 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
117 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
121 #undef GetModuleFileNameEx
124 # define __PMAX (MAX_PATH + 1)
125 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
126 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
127 # define STARTUPINFO STARTUPINFOA
128 # define CreateProcess CreateProcessA
129 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
130 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
132 # define __PMAX PATH_MAX
133 /* The starting and ending address of the cygwin1.dll text segment. */
134 static CORE_ADDR cygwin_load_start
;
135 static CORE_ADDR cygwin_load_end
;
137 typedef wchar_t cygwin_buf_t
;
138 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
140 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
141 # define STARTUPINFO STARTUPINFOW
142 # define CreateProcess CreateProcessW
143 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
144 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
147 static int have_saved_context
; /* True if we've saved context from a
149 static CONTEXT saved_context
; /* Containes the saved context from a
152 /* If we're not using the old Cygwin header file set, define the
153 following which never should have been in the generic Win32 API
154 headers in the first place since they were our own invention... */
155 #ifndef _GNU_H_WINDOWS_H
158 FLAG_TRACE_BIT
= 0x100,
162 #ifndef CONTEXT_EXTENDED_REGISTERS
163 /* This macro is only defined on ia32. It only makes sense on this target,
164 so define it as zero if not already defined. */
165 #define CONTEXT_EXTENDED_REGISTERS 0
168 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
169 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
170 | CONTEXT_EXTENDED_REGISTERS
172 static uintptr_t dr
[8];
173 static int debug_registers_changed
;
174 static int debug_registers_used
;
176 static int windows_initialization_done
;
177 #define DR6_CLEAR_VALUE 0xffff0ff0
179 /* The exception thrown by a program to tell the debugger the name of
180 a thread. The exception record contains an ID of a thread and a
181 name to give it. This exception has no documented name, but MSDN
182 dubs it "MS_VC_EXCEPTION" in one code example. */
183 #define MS_VC_EXCEPTION 0x406d1388
187 HANDLE_EXCEPTION_UNHANDLED
= 0,
188 HANDLE_EXCEPTION_HANDLED
,
189 HANDLE_EXCEPTION_IGNORED
190 } handle_exception_result
;
192 /* The string sent by cygwin when it processes a signal.
193 FIXME: This should be in a cygwin include file. */
194 #ifndef _CYGWIN_SIGNAL_STRING
195 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
198 #define CHECK(x) check (x, __FILE__,__LINE__)
199 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
200 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
201 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
202 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
204 static void windows_interrupt (struct target_ops
*self
);
205 static int windows_thread_alive (struct target_ops
*, ptid_t
);
206 static void windows_kill_inferior (struct target_ops
*);
208 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
209 static void cygwin_set_dr7 (unsigned long val
);
210 static CORE_ADDR
cygwin_get_dr (int i
);
211 static unsigned long cygwin_get_dr6 (void);
212 static unsigned long cygwin_get_dr7 (void);
214 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
215 /* Set if a signal was received from the debugged process. */
217 /* Thread information structure used to track information that is
218 not available in gdb's thread structure. */
219 typedef struct windows_thread_info_struct
221 struct windows_thread_info_struct
*next
;
224 CORE_ADDR thread_local_base
;
233 static windows_thread_info thread_head
;
235 /* The process and thread handles for the above context. */
237 static DEBUG_EVENT current_event
; /* The current debug event from
239 static HANDLE current_process_handle
; /* Currently executing process */
240 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
241 static DWORD main_thread_id
; /* Thread ID of the main thread */
243 /* Counts of things. */
244 static int exception_count
= 0;
245 static int event_count
= 0;
246 static int saw_create
;
247 static int open_process_used
= 0;
250 static int new_console
= 0;
252 static int cygwin_exceptions
= 0;
254 static int new_group
= 1;
255 static int debug_exec
= 0; /* show execution */
256 static int debug_events
= 0; /* show events from kernel */
257 static int debug_memory
= 0; /* show target memory accesses */
258 static int debug_exceptions
= 0; /* show target exceptions */
259 static int useshell
= 0; /* use shell for subprocesses */
261 /* This vector maps GDB's idea of a register's number into an offset
262 in the windows exception context vector.
264 It also contains the bit mask needed to load the register in question.
266 The contents of this table can only be computed by the units
267 that provide CPU-specific support for Windows native debugging.
268 These units should set the table by calling
269 windows_set_context_register_offsets.
271 One day we could read a reg, we could inspect the context we
272 already have loaded, if it doesn't have the bit set that we need,
273 we read that set of registers in using GetThreadContext. If the
274 context already contains what we need, we just unpack it. Then to
275 write a register, first we have to ensure that the context contains
276 the other regs of the group, and then we copy the info in and set
279 static const int *mappings
;
281 /* The function to use in order to determine whether a register is
282 a segment register or not. */
283 static segment_register_p_ftype
*segment_register_p
;
285 /* This vector maps the target's idea of an exception (extracted
286 from the DEBUG_EVENT structure) to GDB's idea. */
288 struct xlate_exception
294 static const struct xlate_exception
297 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
298 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
299 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
300 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
301 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
302 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
303 {-1, GDB_SIGNAL_UNKNOWN
}};
305 /* Set the MAPPINGS static global to OFFSETS.
306 See the description of MAPPINGS for more details. */
309 windows_set_context_register_offsets (const int *offsets
)
314 /* See windows-nat.h. */
317 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
319 segment_register_p
= fun
;
323 check (BOOL ok
, const char *file
, int line
)
326 printf_filtered ("error return %s:%d was %u\n", file
, line
,
327 (unsigned) GetLastError ());
330 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
331 then also retrieve the context for this thread. If GET_CONTEXT is
332 negative, then don't suspend the thread. */
333 static windows_thread_info
*
334 thread_rec (DWORD id
, int get_context
)
336 windows_thread_info
*th
;
338 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
341 if (!th
->suspended
&& get_context
)
343 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
345 if (SuspendThread (th
->h
) == (DWORD
) -1)
347 DWORD err
= GetLastError ();
349 /* We get Access Denied (5) when trying to suspend
350 threads that Windows started on behalf of the
351 debuggee, usually when those threads are just
353 We can get Invalid Handle (6) if the main thread
355 if (err
!= ERROR_INVALID_HANDLE
356 && err
!= ERROR_ACCESS_DENIED
)
357 warning (_("SuspendThread (tid=0x%x) failed."
359 (unsigned) id
, (unsigned) err
);
365 else if (get_context
< 0)
367 th
->reload_context
= 1;
375 /* Add a thread to the thread list. */
376 static windows_thread_info
*
377 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
379 windows_thread_info
*th
;
382 gdb_assert (ptid_get_tid (ptid
) != 0);
384 id
= ptid_get_tid (ptid
);
386 if ((th
= thread_rec (id
, FALSE
)))
389 th
= XCNEW (windows_thread_info
);
392 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
393 th
->next
= thread_head
.next
;
394 thread_head
.next
= th
;
396 /* Set the debug registers for the new thread if they are used. */
397 if (debug_registers_used
)
399 /* Only change the value of the debug registers. */
400 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
401 CHECK (GetThreadContext (th
->h
, &th
->context
));
402 th
->context
.Dr0
= dr
[0];
403 th
->context
.Dr1
= dr
[1];
404 th
->context
.Dr2
= dr
[2];
405 th
->context
.Dr3
= dr
[3];
406 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
407 th
->context
.Dr7
= dr
[7];
408 CHECK (SetThreadContext (th
->h
, &th
->context
));
409 th
->context
.ContextFlags
= 0;
414 /* Clear out any old thread list and reinitialize it to a
417 windows_init_thread_list (void)
419 windows_thread_info
*th
= &thread_head
;
421 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
423 while (th
->next
!= NULL
)
425 windows_thread_info
*here
= th
->next
;
426 th
->next
= here
->next
;
429 thread_head
.next
= NULL
;
432 /* Delete a thread from the list of threads. */
434 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
436 windows_thread_info
*th
;
439 gdb_assert (ptid_get_tid (ptid
) != 0);
441 id
= ptid_get_tid (ptid
);
444 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
445 else if (print_thread_events
&& id
!= main_thread_id
)
446 printf_unfiltered (_("[%s exited with code %u]\n"),
447 target_pid_to_str (ptid
), (unsigned) exit_code
);
448 delete_thread (ptid
);
450 for (th
= &thread_head
;
451 th
->next
!= NULL
&& th
->next
->id
!= id
;
455 if (th
->next
!= NULL
)
457 windows_thread_info
*here
= th
->next
;
458 th
->next
= here
->next
;
465 do_windows_fetch_inferior_registers (struct regcache
*regcache
,
466 windows_thread_info
*th
, int r
)
468 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
469 struct gdbarch
*gdbarch
= regcache
->arch ();
470 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
473 if (th
->reload_context
)
476 if (have_saved_context
)
478 /* Lie about where the program actually is stopped since
479 cygwin has informed us that we should consider the signal
480 to have occurred at another location which is stored in
482 memcpy (&th
->context
, &saved_context
,
483 __COPY_CONTEXT_SIZE
);
484 have_saved_context
= 0;
489 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
490 CHECK (GetThreadContext (th
->h
, &th
->context
));
491 /* Copy dr values from that thread.
492 But only if there were not modified since last stop.
494 if (!debug_registers_changed
)
496 dr
[0] = th
->context
.Dr0
;
497 dr
[1] = th
->context
.Dr1
;
498 dr
[2] = th
->context
.Dr2
;
499 dr
[3] = th
->context
.Dr3
;
500 dr
[6] = th
->context
.Dr6
;
501 dr
[7] = th
->context
.Dr7
;
504 th
->reload_context
= 0;
507 if (r
== I387_FISEG_REGNUM (tdep
))
509 l
= *((long *) context_offset
) & 0xffff;
510 regcache_raw_supply (regcache
, r
, (char *) &l
);
512 else if (r
== I387_FOP_REGNUM (tdep
))
514 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
515 regcache_raw_supply (regcache
, r
, (char *) &l
);
517 else if (segment_register_p (r
))
519 /* GDB treats segment registers as 32bit registers, but they are
520 in fact only 16 bits long. Make sure we do not read extra
521 bits from our source buffer. */
522 l
= *((long *) context_offset
) & 0xffff;
523 regcache_raw_supply (regcache
, r
, (char *) &l
);
526 regcache_raw_supply (regcache
, r
, context_offset
);
529 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
530 do_windows_fetch_inferior_registers (regcache
, th
, r
);
535 windows_fetch_inferior_registers (struct target_ops
*ops
,
536 struct regcache
*regcache
, int r
)
538 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
539 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
541 /* Check if TH exists. Windows sometimes uses a non-existent
542 thread id in its events. */
544 do_windows_fetch_inferior_registers (regcache
, th
, r
);
548 do_windows_store_inferior_registers (const struct regcache
*regcache
,
549 windows_thread_info
*th
, int r
)
552 regcache_raw_collect (regcache
, r
,
553 ((char *) &th
->context
) + mappings
[r
]);
556 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
557 do_windows_store_inferior_registers (regcache
, th
, r
);
561 /* Store a new register value into the context of the thread tied to
564 windows_store_inferior_registers (struct target_ops
*ops
,
565 struct regcache
*regcache
, int r
)
567 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
568 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
570 /* Check if TH exists. Windows sometimes uses a non-existent
571 thread id in its events. */
573 do_windows_store_inferior_registers (regcache
, th
, r
);
576 /* Encapsulate the information required in a call to
577 symbol_file_add_args. */
578 struct safe_symbol_file_add_args
582 section_addr_info
*addrs
;
585 struct ui_file
*err
, *out
;
589 /* Maintain a linked list of "so" information. */
590 struct lm_info_windows
: public lm_info_base
592 LPVOID load_addr
= 0;
595 static struct so_list solib_start
, *solib_end
;
597 static struct so_list
*
598 windows_make_so (const char *name
, LPVOID load_addr
)
605 WIN32_FIND_DATA w32_fd
;
606 HANDLE h
= FindFirstFile(name
, &w32_fd
);
608 if (h
== INVALID_HANDLE_VALUE
)
614 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
616 p
= strrchr (buf
, '\\');
619 SetCurrentDirectory (buf
);
620 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
621 SetCurrentDirectory (cwd
);
624 if (strcasecmp (buf
, "ntdll.dll") == 0)
626 GetSystemDirectory (buf
, sizeof (buf
));
627 strcat (buf
, "\\ntdll.dll");
630 cygwin_buf_t buf
[__PMAX
];
633 if (access (name
, F_OK
) != 0)
635 if (strcasecmp (name
, "ntdll.dll") == 0)
638 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
639 wcscat (buf
, L
"\\ntdll.dll");
643 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
644 strcat (buf
, "\\ntdll.dll");
649 so
= XCNEW (struct so_list
);
650 lm_info_windows
*li
= new lm_info_windows
;
652 li
->load_addr
= load_addr
;
653 strcpy (so
->so_original_name
, name
);
655 strcpy (so
->so_name
, buf
);
658 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
659 SO_NAME_MAX_PATH_SIZE
);
662 char *rname
= realpath (name
, NULL
);
663 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
665 strcpy (so
->so_name
, rname
);
669 error (_("dll path too long"));
671 /* Record cygwin1.dll .text start/end. */
672 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
673 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
675 asection
*text
= NULL
;
678 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
683 if (bfd_check_format (abfd
.get (), bfd_object
))
684 text
= bfd_get_section_by_name (abfd
.get (), ".text");
689 /* The symbols in a dll are offset by 0x1000, which is the
690 offset from 0 of the first byte in an image - because of the
691 file header and the section alignment. */
692 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
694 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
703 get_image_name (HANDLE h
, void *address
, int unicode
)
706 static char buf
[__PMAX
];
708 static char buf
[(2 * __PMAX
) + 1];
710 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
716 /* Attempt to read the name of the dll that was detected.
717 This is documented to work only when actively debugging
718 a program. It will not work for attached processes. */
722 /* See if we could read the address of a string, and that the
723 address isn't null. */
724 if (!ReadProcessMemory (h
, address
, &address_ptr
,
725 sizeof (address_ptr
), &done
)
726 || done
!= sizeof (address_ptr
) || !address_ptr
)
729 /* Find the length of the string. */
730 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
731 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
735 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
738 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
739 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
742 wcstombs (buf
, unicode_address
, __PMAX
);
744 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
752 /* Handle a DLL load event, and return 1.
754 This function assumes that this event did not occur during inferior
755 initialization, where their event info may be incomplete (see
756 do_initial_windows_stuff and windows_add_all_dlls for more info
757 on how we handle DLL loading during that phase). */
762 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
765 /* Try getting the DLL name via the lpImageName field of the event.
766 Note that Microsoft documents this fields as strictly optional,
767 in the sense that it might be NULL. And the first DLL event in
768 particular is explicitly documented as "likely not pass[ed]"
769 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
770 dll_name
= get_image_name (current_process_handle
,
771 event
->lpImageName
, event
->fUnicode
);
775 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
776 solib_end
= solib_end
->next
;
778 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
780 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
781 host_address_to_string (li
->load_addr
)));
785 windows_free_so (struct so_list
*so
)
787 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
793 /* Handle a DLL unload event.
794 Return 1 if successful, or zero otherwise.
796 This function assumes that this event did not occur during inferior
797 initialization, where their event info may be incomplete (see
798 do_initial_windows_stuff and windows_add_all_dlls for more info
799 on how we handle DLL loading during that phase). */
804 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
807 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
809 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
811 if (li_next
->load_addr
== lpBaseOfDll
)
813 struct so_list
*sodel
= so
->next
;
815 so
->next
= sodel
->next
;
818 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
820 windows_free_so (sodel
);
825 /* We did not find any DLL that was previously loaded at this address,
826 so register a complaint. We do not report an error, because we have
827 observed that this may be happening under some circumstances. For
828 instance, running 32bit applications on x64 Windows causes us to receive
829 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
830 events are apparently caused by the WOW layer, the interface between
831 32bit and 64bit worlds). */
832 complaint (&symfile_complaints
, _("dll starting at %s not found."),
833 host_address_to_string (lpBaseOfDll
));
836 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
840 catch_errors (void (*func
) ())
846 CATCH (ex
, RETURN_MASK_ALL
)
848 exception_print (gdb_stderr
, ex
);
853 /* Clear list of loaded DLLs. */
855 windows_clear_solib (void)
857 solib_start
.next
= NULL
;
858 solib_end
= &solib_start
;
862 signal_event_command (const char *args
, int from_tty
)
864 uintptr_t event_id
= 0;
865 char *endargs
= NULL
;
868 error (_("signal-event requires an argument (integer event id)"));
870 event_id
= strtoumax (args
, &endargs
, 10);
872 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
873 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
874 error (_("Failed to convert `%s' to event id"), args
);
876 SetEvent ((HANDLE
) event_id
);
877 CloseHandle ((HANDLE
) event_id
);
880 /* Handle DEBUG_STRING output from child process.
881 Cygwin prepends its messages with a "cygwin:". Interpret this as
882 a Cygwin signal. Otherwise just print the string as a warning. */
884 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
886 gdb::unique_xmalloc_ptr
<char> s
;
889 if (!target_read_string
890 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
892 || !s
|| !*(s
.get ()))
894 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
897 if (!startswith (s
.get (), "cYg"))
900 char *p
= strchr (s
.get (), '\0');
902 if (p
> s
.get () && *--p
== '\n')
904 warning (("%s"), s
.get ());
910 /* Got a cygwin signal marker. A cygwin signal is followed by
911 the signal number itself and then optionally followed by the
912 thread id and address to saved context within the DLL. If
913 these are supplied, then the given thread is assumed to have
914 issued the signal and the context from the thread is assumed
915 to be stored at the given address in the inferior. Tell gdb
916 to treat this like a real signal. */
918 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
919 gdb_signal gotasig
= gdb_signal_from_host (sig
);
921 ourstatus
->value
.sig
= gotasig
;
927 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
928 retval
= strtoul (p
, &p
, 0);
930 retval
= main_thread_id
;
931 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
932 && ReadProcessMemory (current_process_handle
, x
,
934 __COPY_CONTEXT_SIZE
, &n
)
935 && n
== __COPY_CONTEXT_SIZE
)
936 have_saved_context
= 1;
945 display_selector (HANDLE thread
, DWORD sel
)
948 if (GetThreadSelectorEntry (thread
, sel
, &info
))
951 printf_filtered ("0x%03x: ", (unsigned) sel
);
952 if (!info
.HighWord
.Bits
.Pres
)
954 puts_filtered ("Segment not present\n");
957 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
958 (info
.HighWord
.Bits
.BaseMid
<< 16)
960 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
961 if (info
.HighWord
.Bits
.Granularity
)
962 limit
= (limit
<< 12) | 0xfff;
963 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
964 if (info
.HighWord
.Bits
.Default_Big
)
965 puts_filtered(" 32-bit ");
967 puts_filtered(" 16-bit ");
968 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
971 puts_filtered ("Data (Read-Only, Exp-up");
974 puts_filtered ("Data (Read/Write, Exp-up");
977 puts_filtered ("Unused segment (");
980 puts_filtered ("Data (Read/Write, Exp-down");
983 puts_filtered ("Code (Exec-Only, N.Conf");
986 puts_filtered ("Code (Exec/Read, N.Conf");
989 puts_filtered ("Code (Exec-Only, Conf");
992 puts_filtered ("Code (Exec/Read, Conf");
995 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
997 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
998 puts_filtered(", N.Acc");
999 puts_filtered (")\n");
1000 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1001 puts_filtered("System selector ");
1002 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1003 if (info
.HighWord
.Bits
.Granularity
)
1004 puts_filtered ("Page granular.\n");
1006 puts_filtered ("Byte granular.\n");
1011 DWORD err
= GetLastError ();
1012 if (err
== ERROR_NOT_SUPPORTED
)
1013 printf_filtered ("Function not supported\n");
1015 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1021 display_selectors (const char * args
, int from_tty
)
1023 if (!current_thread
)
1025 puts_filtered ("Impossible to display selectors now.\n");
1031 puts_filtered ("Selector $cs\n");
1032 display_selector (current_thread
->h
,
1033 current_thread
->context
.SegCs
);
1034 puts_filtered ("Selector $ds\n");
1035 display_selector (current_thread
->h
,
1036 current_thread
->context
.SegDs
);
1037 puts_filtered ("Selector $es\n");
1038 display_selector (current_thread
->h
,
1039 current_thread
->context
.SegEs
);
1040 puts_filtered ("Selector $ss\n");
1041 display_selector (current_thread
->h
,
1042 current_thread
->context
.SegSs
);
1043 puts_filtered ("Selector $fs\n");
1044 display_selector (current_thread
->h
,
1045 current_thread
->context
.SegFs
);
1046 puts_filtered ("Selector $gs\n");
1047 display_selector (current_thread
->h
,
1048 current_thread
->context
.SegGs
);
1053 sel
= parse_and_eval_long (args
);
1054 printf_filtered ("Selector \"%s\"\n",args
);
1055 display_selector (current_thread
->h
, sel
);
1059 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1060 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1061 host_address_to_string (\
1062 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1064 static handle_exception_result
1065 handle_exception (struct target_waitstatus
*ourstatus
)
1067 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1068 DWORD code
= rec
->ExceptionCode
;
1069 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1071 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1073 /* Record the context of the current thread. */
1074 thread_rec (current_event
.dwThreadId
, -1);
1078 case EXCEPTION_ACCESS_VIOLATION
:
1079 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1080 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1083 /* See if the access violation happened within the cygwin DLL
1084 itself. Cygwin uses a kind of exception handling to deal
1085 with passed-in invalid addresses. gdb should not treat
1086 these as real SEGVs since they will be silently handled by
1087 cygwin. A real SEGV will (theoretically) be caught by
1088 cygwin later in the process and will be sent as a
1089 cygwin-specific-signal. So, ignore SEGVs if they show up
1090 within the text segment of the DLL itself. */
1092 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1094 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1095 && addr
< cygwin_load_end
))
1096 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1097 && startswith (fn
, "KERNEL32!IsBad")))
1098 return HANDLE_EXCEPTION_UNHANDLED
;
1102 case STATUS_STACK_OVERFLOW
:
1103 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1104 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1106 case STATUS_FLOAT_DENORMAL_OPERAND
:
1107 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1108 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1110 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1111 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1112 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1114 case STATUS_FLOAT_INEXACT_RESULT
:
1115 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1116 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1118 case STATUS_FLOAT_INVALID_OPERATION
:
1119 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1120 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1122 case STATUS_FLOAT_OVERFLOW
:
1123 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1124 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1126 case STATUS_FLOAT_STACK_CHECK
:
1127 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1128 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1130 case STATUS_FLOAT_UNDERFLOW
:
1131 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1132 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1134 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1135 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1136 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1138 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1139 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1140 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1142 case STATUS_INTEGER_OVERFLOW
:
1143 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1144 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1146 case EXCEPTION_BREAKPOINT
:
1147 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1148 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1151 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1152 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1154 case DBG_CONTROL_BREAK
:
1155 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1156 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1158 case EXCEPTION_SINGLE_STEP
:
1159 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1160 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1162 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1163 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1164 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1166 case EXCEPTION_PRIV_INSTRUCTION
:
1167 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1168 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1170 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1171 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1172 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1174 case MS_VC_EXCEPTION
:
1175 if (rec
->NumberParameters
>= 3
1176 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1178 DWORD named_thread_id
;
1179 windows_thread_info
*named_thread
;
1180 CORE_ADDR thread_name_target
;
1182 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1184 thread_name_target
= rec
->ExceptionInformation
[1];
1185 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1187 if (named_thread_id
== (DWORD
) -1)
1188 named_thread_id
= current_event
.dwThreadId
;
1190 named_thread
= thread_rec (named_thread_id
, 0);
1191 if (named_thread
!= NULL
)
1193 int thread_name_len
;
1194 gdb::unique_xmalloc_ptr
<char> thread_name
;
1196 thread_name_len
= target_read_string (thread_name_target
,
1197 &thread_name
, 1025, NULL
);
1198 if (thread_name_len
> 0)
1200 thread_name
.get ()[thread_name_len
- 1] = '\0';
1201 xfree (named_thread
->name
);
1202 named_thread
->name
= thread_name
.release ();
1205 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1206 result
= HANDLE_EXCEPTION_IGNORED
;
1209 /* treat improperly formed exception as unknown, fallthrough */
1211 /* Treat unhandled first chance exceptions specially. */
1212 if (current_event
.u
.Exception
.dwFirstChance
)
1213 return HANDLE_EXCEPTION_UNHANDLED
;
1214 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1215 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1216 host_address_to_string (
1217 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1218 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1222 last_sig
= ourstatus
->value
.sig
;
1226 /* Resume thread specified by ID, or all artificially suspended
1227 threads, if we are continuing execution. KILLED non-zero means we
1228 have killed the inferior, so we should ignore weird errors due to
1229 threads shutting down. */
1231 windows_continue (DWORD continue_status
, int id
, int killed
)
1234 windows_thread_info
*th
;
1237 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1238 (unsigned) current_event
.dwProcessId
,
1239 (unsigned) current_event
.dwThreadId
,
1240 continue_status
== DBG_CONTINUE
?
1241 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1243 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1244 if ((id
== -1 || id
== (int) th
->id
)
1247 if (debug_registers_changed
)
1249 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1250 th
->context
.Dr0
= dr
[0];
1251 th
->context
.Dr1
= dr
[1];
1252 th
->context
.Dr2
= dr
[2];
1253 th
->context
.Dr3
= dr
[3];
1254 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1255 th
->context
.Dr7
= dr
[7];
1257 if (th
->context
.ContextFlags
)
1261 if (GetExitCodeThread (th
->h
, &ec
)
1262 && ec
== STILL_ACTIVE
)
1264 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1269 th
->context
.ContextFlags
= 0;
1271 if (th
->suspended
> 0)
1272 (void) ResumeThread (th
->h
);
1276 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1277 current_event
.dwThreadId
,
1281 error (_("Failed to resume program execution"
1282 " (ContinueDebugEvent failed, error %u)"),
1283 (unsigned int) GetLastError ());
1285 debug_registers_changed
= 0;
1289 /* Called in pathological case where Windows fails to send a
1290 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1292 fake_create_process (void)
1294 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1295 current_event
.dwProcessId
);
1296 if (current_process_handle
!= NULL
)
1297 open_process_used
= 1;
1300 error (_("OpenProcess call failed, GetLastError = %u"),
1301 (unsigned) GetLastError ());
1302 /* We can not debug anything in that case. */
1304 main_thread_id
= current_event
.dwThreadId
;
1305 current_thread
= windows_add_thread (
1306 ptid_build (current_event
.dwProcessId
, 0,
1307 current_event
.dwThreadId
),
1308 current_event
.u
.CreateThread
.hThread
,
1309 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1310 return main_thread_id
;
1314 windows_resume (struct target_ops
*ops
,
1315 ptid_t ptid
, int step
, enum gdb_signal sig
)
1317 windows_thread_info
*th
;
1318 DWORD continue_status
= DBG_CONTINUE
;
1320 /* A specific PTID means `step only this thread id'. */
1321 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1323 /* If we're continuing all threads, it's the current inferior that
1324 should be handled specially. */
1326 ptid
= inferior_ptid
;
1328 if (sig
!= GDB_SIGNAL_0
)
1330 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1332 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1334 else if (sig
== last_sig
)
1335 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1338 /* This code does not seem to work, because
1339 the kernel does probably not consider changes in the ExceptionRecord
1340 structure when passing the exception to the inferior.
1341 Note that this seems possible in the exception handler itself. */
1344 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1345 if (xlate
[i
].us
== sig
)
1347 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1349 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1352 if (continue_status
== DBG_CONTINUE
)
1354 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1358 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1362 last_sig
= GDB_SIGNAL_0
;
1364 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1365 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1367 /* Get context for currently selected thread. */
1368 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1373 /* Single step by setting t bit. */
1374 struct regcache
*regcache
= get_current_regcache ();
1375 struct gdbarch
*gdbarch
= regcache
->arch ();
1376 windows_fetch_inferior_registers (ops
, regcache
,
1377 gdbarch_ps_regnum (gdbarch
));
1378 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1381 if (th
->context
.ContextFlags
)
1383 if (debug_registers_changed
)
1385 th
->context
.Dr0
= dr
[0];
1386 th
->context
.Dr1
= dr
[1];
1387 th
->context
.Dr2
= dr
[2];
1388 th
->context
.Dr3
= dr
[3];
1389 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1390 th
->context
.Dr7
= dr
[7];
1392 CHECK (SetThreadContext (th
->h
, &th
->context
));
1393 th
->context
.ContextFlags
= 0;
1397 /* Allow continuing with the same signal that interrupted us.
1398 Otherwise complain. */
1401 windows_continue (continue_status
, -1, 0);
1403 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1406 /* Ctrl-C handler used when the inferior is not run in the same console. The
1407 handler is in charge of interrupting the inferior using DebugBreakProcess.
1408 Note that this function is not available prior to Windows XP. In this case
1409 we emit a warning. */
1411 ctrl_c_handler (DWORD event_type
)
1413 const int attach_flag
= current_inferior ()->attach_flag
;
1415 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1416 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1419 /* If the inferior and the debugger share the same console, do nothing as
1420 the inferior has also received the Ctrl-C event. */
1421 if (!new_console
&& !attach_flag
)
1424 if (!DebugBreakProcess (current_process_handle
))
1425 warning (_("Could not interrupt program. "
1426 "Press Ctrl-c in the program console."));
1428 /* Return true to tell that Ctrl-C has been handled. */
1432 /* Get the next event from the child. Returns a non-zero thread id if the event
1433 requires handling by WFI (or whatever). */
1435 get_windows_debug_event (struct target_ops
*ops
,
1436 int pid
, struct target_waitstatus
*ourstatus
)
1439 DWORD continue_status
, event_code
;
1440 windows_thread_info
*th
;
1441 static windows_thread_info dummy_thread_info
;
1442 DWORD thread_id
= 0;
1444 last_sig
= GDB_SIGNAL_0
;
1446 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1450 continue_status
= DBG_CONTINUE
;
1452 event_code
= current_event
.dwDebugEventCode
;
1453 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1455 have_saved_context
= 0;
1459 case CREATE_THREAD_DEBUG_EVENT
:
1460 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1461 (unsigned) current_event
.dwProcessId
,
1462 (unsigned) current_event
.dwThreadId
,
1463 "CREATE_THREAD_DEBUG_EVENT"));
1464 if (saw_create
!= 1)
1466 struct inferior
*inf
;
1467 inf
= find_inferior_pid (current_event
.dwProcessId
);
1468 if (!saw_create
&& inf
->attach_flag
)
1470 /* Kludge around a Windows bug where first event is a create
1471 thread event. Caused when attached process does not have
1473 thread_id
= fake_create_process ();
1479 /* Record the existence of this thread. */
1480 thread_id
= current_event
.dwThreadId
;
1481 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1482 current_event
.dwThreadId
),
1483 current_event
.u
.CreateThread
.hThread
,
1484 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1488 case EXIT_THREAD_DEBUG_EVENT
:
1489 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1490 (unsigned) current_event
.dwProcessId
,
1491 (unsigned) current_event
.dwThreadId
,
1492 "EXIT_THREAD_DEBUG_EVENT"));
1494 if (current_event
.dwThreadId
!= main_thread_id
)
1496 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1497 current_event
.dwThreadId
),
1498 current_event
.u
.ExitThread
.dwExitCode
);
1499 th
= &dummy_thread_info
;
1503 case CREATE_PROCESS_DEBUG_EVENT
:
1504 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1505 (unsigned) current_event
.dwProcessId
,
1506 (unsigned) current_event
.dwThreadId
,
1507 "CREATE_PROCESS_DEBUG_EVENT"));
1508 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1509 if (++saw_create
!= 1)
1512 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1514 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1517 main_thread_id
= current_event
.dwThreadId
;
1518 /* Add the main thread. */
1519 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1520 current_event
.dwThreadId
),
1521 current_event
.u
.CreateProcessInfo
.hThread
,
1522 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1523 thread_id
= current_event
.dwThreadId
;
1526 case EXIT_PROCESS_DEBUG_EVENT
:
1527 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1528 (unsigned) current_event
.dwProcessId
,
1529 (unsigned) current_event
.dwThreadId
,
1530 "EXIT_PROCESS_DEBUG_EVENT"));
1531 if (!windows_initialization_done
)
1533 target_terminal::ours ();
1534 target_mourn_inferior (inferior_ptid
);
1535 error (_("During startup program exited with code 0x%x."),
1536 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1538 else if (saw_create
== 1)
1540 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1541 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1542 thread_id
= main_thread_id
;
1546 case LOAD_DLL_DEBUG_EVENT
:
1547 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1548 (unsigned) current_event
.dwProcessId
,
1549 (unsigned) current_event
.dwThreadId
,
1550 "LOAD_DLL_DEBUG_EVENT"));
1551 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1552 if (saw_create
!= 1 || ! windows_initialization_done
)
1554 catch_errors (handle_load_dll
);
1555 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1556 ourstatus
->value
.integer
= 0;
1557 thread_id
= main_thread_id
;
1560 case UNLOAD_DLL_DEBUG_EVENT
:
1561 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1562 (unsigned) current_event
.dwProcessId
,
1563 (unsigned) current_event
.dwThreadId
,
1564 "UNLOAD_DLL_DEBUG_EVENT"));
1565 if (saw_create
!= 1 || ! windows_initialization_done
)
1567 catch_errors (handle_unload_dll
);
1568 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1569 ourstatus
->value
.integer
= 0;
1570 thread_id
= main_thread_id
;
1573 case EXCEPTION_DEBUG_EVENT
:
1574 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1575 (unsigned) current_event
.dwProcessId
,
1576 (unsigned) current_event
.dwThreadId
,
1577 "EXCEPTION_DEBUG_EVENT"));
1578 if (saw_create
!= 1)
1580 switch (handle_exception (ourstatus
))
1582 case HANDLE_EXCEPTION_UNHANDLED
:
1584 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1586 case HANDLE_EXCEPTION_HANDLED
:
1587 thread_id
= current_event
.dwThreadId
;
1589 case HANDLE_EXCEPTION_IGNORED
:
1590 continue_status
= DBG_CONTINUE
;
1595 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1596 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1597 (unsigned) current_event
.dwProcessId
,
1598 (unsigned) current_event
.dwThreadId
,
1599 "OUTPUT_DEBUG_STRING_EVENT"));
1600 if (saw_create
!= 1)
1602 thread_id
= handle_output_debug_string (ourstatus
);
1606 if (saw_create
!= 1)
1608 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1609 (unsigned) current_event
.dwProcessId
,
1610 (unsigned) current_event
.dwThreadId
);
1611 printf_unfiltered (" unknown event code %u\n",
1612 (unsigned) current_event
.dwDebugEventCode
);
1616 if (!thread_id
|| saw_create
!= 1)
1618 CHECK (windows_continue (continue_status
, -1, 0));
1622 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1624 current_thread
= th
;
1625 if (!current_thread
)
1626 current_thread
= thread_rec (thread_id
, TRUE
);
1633 /* Wait for interesting events to occur in the target process. */
1635 windows_wait (struct target_ops
*ops
,
1636 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1640 target_terminal::ours ();
1642 /* We loop when we get a non-standard exception rather than return
1643 with a SPURIOUS because resume can try and step or modify things,
1644 which needs a current_thread->h. But some of these exceptions mark
1645 the birth or death of threads, which mean that the current thread
1646 isn't necessarily what you think it is. */
1652 /* If the user presses Ctrl-c while the debugger is waiting
1653 for an event, he expects the debugger to interrupt his program
1654 and to get the prompt back. There are two possible situations:
1656 - The debugger and the program do not share the console, in
1657 which case the Ctrl-c event only reached the debugger.
1658 In that case, the ctrl_c handler will take care of interrupting
1659 the inferior. Note that this case is working starting with
1660 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1663 - The debugger and the program share the same console, in which
1664 case both debugger and inferior will receive the Ctrl-c event.
1665 In that case the ctrl_c handler will ignore the event, as the
1666 Ctrl-c event generated inside the inferior will trigger the
1667 expected debug event.
1669 FIXME: brobecker/2008-05-20: If the inferior receives the
1670 signal first and the delay until GDB receives that signal
1671 is sufficiently long, GDB can sometimes receive the SIGINT
1672 after we have unblocked the CTRL+C handler. This would
1673 lead to the debugger stopping prematurely while handling
1674 the new-thread event that comes with the handling of the SIGINT
1675 inside the inferior, and then stop again immediately when
1676 the user tries to resume the execution in the inferior.
1677 This is a classic race that we should try to fix one day. */
1678 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1679 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1680 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1683 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1688 if (deprecated_ui_loop_hook
!= NULL
)
1689 detach
= deprecated_ui_loop_hook (0);
1692 windows_kill_inferior (ops
);
1697 /* Iterate over all DLLs currently mapped by our inferior, and
1698 add them to our list of solibs. */
1701 windows_add_all_dlls (void)
1704 HMODULE dummy_hmodule
;
1709 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1710 sizeof (HMODULE
), &cb_needed
) == 0)
1716 hmodules
= (HMODULE
*) alloca (cb_needed
);
1717 if (EnumProcessModules (current_process_handle
, hmodules
,
1718 cb_needed
, &cb_needed
) == 0)
1721 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1725 wchar_t dll_name
[__PMAX
];
1728 char dll_name
[__PMAX
];
1731 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1732 &mi
, sizeof (mi
)) == 0)
1734 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1735 dll_name
, sizeof (dll_name
)) == 0)
1738 wcstombs (name
, dll_name
, __PMAX
);
1743 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1744 solib_end
= solib_end
->next
;
1749 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1752 struct inferior
*inf
;
1753 struct thread_info
*tp
;
1755 last_sig
= GDB_SIGNAL_0
;
1757 exception_count
= 0;
1758 open_process_used
= 0;
1759 debug_registers_changed
= 0;
1760 debug_registers_used
= 0;
1761 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1764 cygwin_load_start
= cygwin_load_end
= 0;
1766 current_event
.dwProcessId
= pid
;
1767 memset (¤t_event
, 0, sizeof (current_event
));
1768 if (!target_is_pushed (ops
))
1770 disable_breakpoints_in_shlibs ();
1771 windows_clear_solib ();
1772 clear_proceed_status (0);
1773 init_wait_for_inferior ();
1775 inf
= current_inferior ();
1776 inferior_appeared (inf
, pid
);
1777 inf
->attach_flag
= attaching
;
1779 /* Make the new process the current inferior, so terminal handling
1780 can rely on it. When attaching, we don't know about any thread
1781 id here, but that's OK --- nothing should be referencing the
1782 current thread until we report an event out of windows_wait. */
1783 inferior_ptid
= pid_to_ptid (pid
);
1785 target_terminal::init ();
1786 target_terminal::inferior ();
1788 windows_initialization_done
= 0;
1792 struct target_waitstatus status
;
1794 windows_wait (ops
, minus_one_ptid
, &status
, 0);
1796 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1798 if (status
.kind
!= TARGET_WAITKIND_LOADED
1799 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1802 windows_resume (ops
, minus_one_ptid
, 0, GDB_SIGNAL_0
);
1805 /* Now that the inferior has been started and all DLLs have been mapped,
1806 we can iterate over all DLLs and load them in.
1808 We avoid doing it any earlier because, on certain versions of Windows,
1809 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1810 we have seen on Windows 8.1 that the ntdll.dll load event does not
1811 include the DLL name, preventing us from creating an associated SO.
1812 A possible explanation is that ntdll.dll might be mapped before
1813 the SO info gets created by the Windows system -- ntdll.dll is
1814 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1815 do not seem to suffer from that problem.
1817 Rather than try to work around this sort of issue, it is much
1818 simpler to just ignore DLL load/unload events during the startup
1819 phase, and then process them all in one batch now. */
1820 windows_add_all_dlls ();
1822 windows_initialization_done
= 1;
1826 /* Try to set or remove a user privilege to the current process. Return -1
1827 if that fails, the previous setting of that privilege otherwise.
1829 This code is copied from the Cygwin source code and rearranged to allow
1830 dynamically loading of the needed symbols from advapi32 which is only
1831 available on NT/2K/XP. */
1833 set_process_privilege (const char *privilege
, BOOL enable
)
1835 HANDLE token_hdl
= NULL
;
1837 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1841 if (!OpenProcessToken (GetCurrentProcess (),
1842 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1846 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1849 new_priv
.PrivilegeCount
= 1;
1850 new_priv
.Privileges
[0].Luid
= restore_priv
;
1851 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1853 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1854 sizeof orig_priv
, &orig_priv
, &size
))
1857 /* Disabled, otherwise every `attach' in an unprivileged user session
1858 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1859 windows_attach(). */
1860 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1861 be enabled. GetLastError () returns an correct error code, though. */
1862 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1866 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1870 CloseHandle (token_hdl
);
1875 /* Attach to process PID, then initialize for debugging it. */
1877 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1882 pid
= parse_pid_to_attach (args
);
1884 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1886 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1887 printf_unfiltered ("This can cause attach to "
1888 "fail on Windows NT/2K/XP\n");
1891 windows_init_thread_list ();
1892 ok
= DebugActiveProcess (pid
);
1898 /* Try fall back to Cygwin pid. */
1899 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1902 ok
= DebugActiveProcess (pid
);
1907 error (_("Can't attach to process."));
1909 DebugSetProcessKillOnExit (FALSE
);
1913 char *exec_file
= (char *) get_exec_file (0);
1916 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1917 target_pid_to_str (pid_to_ptid (pid
)));
1919 printf_unfiltered ("Attaching to %s\n",
1920 target_pid_to_str (pid_to_ptid (pid
)));
1922 gdb_flush (gdb_stdout
);
1925 do_initial_windows_stuff (ops
, pid
, 1);
1926 target_terminal::ours ();
1930 windows_detach (struct target_ops
*ops
, inferior
*inf
, int from_tty
)
1934 ptid_t ptid
= minus_one_ptid
;
1935 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1937 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1939 error (_("Can't detach process %u (error %u)"),
1940 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1943 DebugSetProcessKillOnExit (FALSE
);
1945 if (detached
&& from_tty
)
1947 const char *exec_file
= get_exec_file (0);
1950 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1951 (unsigned) current_event
.dwProcessId
);
1952 gdb_flush (gdb_stdout
);
1955 x86_cleanup_dregs ();
1956 inferior_ptid
= null_ptid
;
1957 detach_inferior (current_event
.dwProcessId
);
1959 inf_child_maybe_unpush_target (ops
);
1962 /* Try to determine the executable filename.
1964 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1966 Upon success, the filename is stored inside EXE_NAME_RET, and
1967 this function returns nonzero.
1969 Otherwise, this function returns zero and the contents of
1970 EXE_NAME_RET is undefined. */
1973 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1980 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1981 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1984 /* We know the executable is always first in the list of modules,
1985 which we just fetched. So no need to fetch more. */
1989 /* Cygwin prefers that the path be in /x/y/z format, so extract
1990 the filename into a temporary buffer first, and then convert it
1991 to POSIX format into the destination buffer. */
1992 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1994 len
= GetModuleFileNameEx (current_process_handle
,
1995 dh_buf
, pathbuf
, exe_name_max_len
);
1997 error (_("Error getting executable filename: %u."),
1998 (unsigned) GetLastError ());
1999 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2000 exe_name_max_len
) < 0)
2001 error (_("Error converting executable filename to POSIX: %d."), errno
);
2004 len
= GetModuleFileNameEx (current_process_handle
,
2005 dh_buf
, exe_name_ret
, exe_name_max_len
);
2007 error (_("Error getting executable filename: %u."),
2008 (unsigned) GetLastError ());
2011 return 1; /* success */
2014 /* The pid_to_exec_file target_ops method for this platform. */
2017 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
2019 static char path
[__PMAX
];
2021 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2023 char procexe
[sizeof ("/proc/4294967295/exe")];
2025 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2026 nchars
= readlink (procexe
, path
, sizeof(path
));
2027 if (nchars
> 0 && nchars
< sizeof (path
))
2029 path
[nchars
] = '\0'; /* Got it */
2034 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2035 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2036 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2042 /* Print status information about what we're accessing. */
2045 windows_files_info (struct target_ops
*ignore
)
2047 struct inferior
*inf
= current_inferior ();
2049 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2050 inf
->attach_flag
? "attached" : "child",
2051 target_pid_to_str (inferior_ptid
));
2054 /* Modify CreateProcess parameters for use of a new separate console.
2056 *FLAGS: DWORD parameter for general process creation flags.
2057 *SI: STARTUPINFO structure, for which the console window size and
2058 console buffer size is filled in if GDB is running in a console.
2059 to create the new console.
2060 The size of the used font is not available on all versions of
2061 Windows OS. Furthermore, the current font might not be the default
2062 font, but this is still better than before.
2063 If the windows and buffer sizes are computed,
2064 SI->DWFLAGS is changed so that this information is used
2065 by CreateProcess function. */
2068 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2070 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2071 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2073 if (hconsole
!= INVALID_HANDLE_VALUE
)
2075 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2077 CONSOLE_FONT_INFO cfi
;
2079 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2080 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2081 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2082 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2083 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2085 si
->dwXSize
*= font_size
.X
;
2089 si
->dwYSize
*= font_size
.Y
;
2092 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2093 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2094 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2096 *flags
|= CREATE_NEW_CONSOLE
;
2100 /* Function called by qsort to sort environment strings. */
2103 envvar_cmp (const void *a
, const void *b
)
2105 const char **p
= (const char **) a
;
2106 const char **q
= (const char **) b
;
2107 return strcasecmp (*p
, *q
);
2113 clear_win32_environment (char **env
)
2117 wchar_t *copy
= NULL
, *equalpos
;
2119 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2121 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2122 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2123 mbstowcs (copy
, env
[i
], len
);
2124 equalpos
= wcschr (copy
, L
'=');
2127 SetEnvironmentVariableW (copy
, NULL
);
2135 /* Redirection of inferior I/O streams for native MS-Windows programs.
2136 Unlike on Unix, where this is handled by invoking the inferior via
2137 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2139 The official documentation of the cmd.exe redirection features is here:
2141 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2143 (That page talks about Windows XP, but there's no newer
2144 documentation, so we assume later versions of cmd.exe didn't change
2147 Caveat: the documentation on that page seems to include a few lies.
2148 For example, it describes strange constructs 1<&2 and 2<&1, which
2149 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2150 think the cmd.exe parser of the redirection symbols simply doesn't
2151 care about the < vs > distinction in these cases. Therefore, the
2152 supported features are explicitly documented below.
2154 The emulation below aims at supporting all the valid use cases
2155 supported by cmd.exe, which include:
2157 < FILE redirect standard input from FILE
2158 0< FILE redirect standard input from FILE
2159 <&N redirect standard input from file descriptor N
2160 0<&N redirect standard input from file descriptor N
2161 > FILE redirect standard output to FILE
2162 >> FILE append standard output to FILE
2163 1>> FILE append standard output to FILE
2164 >&N redirect standard output to file descriptor N
2165 1>&N redirect standard output to file descriptor N
2166 >>&N append standard output to file descriptor N
2167 1>>&N append standard output to file descriptor N
2168 2> FILE redirect standard error to FILE
2169 2>> FILE append standard error to FILE
2170 2>&N redirect standard error to file descriptor N
2171 2>>&N append standard error to file descriptor N
2173 Note that using N > 2 in the above construct is supported, but
2174 requires that the corresponding file descriptor be open by some
2175 means elsewhere or outside GDB. Also note that using ">&0" or
2176 "<&2" will generally fail, because the file descriptor redirected
2177 from is normally open in an incompatible mode (e.g., FD 0 is open
2178 for reading only). IOW, use of such tricks is not recommended;
2179 you are on your own.
2181 We do NOT support redirection of file descriptors above 2, as in
2182 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2183 that needs special handling in the startup code that MinGW
2184 doesn't have). Pipes are also not supported.
2186 As for invalid use cases, where the redirection contains some
2187 error, the emulation below will detect that and produce some
2188 error and/or failure. But the behavior in those cases is not
2189 bug-for-bug compatible with what cmd.exe does in those cases.
2190 That's because what cmd.exe does then is not well defined, and
2191 seems to be a side effect of the cmd.exe parsing of the command
2192 line more than anything else. For example, try redirecting to an
2193 invalid file name, as in "> foo:bar".
2195 There are also minor syntactic deviations from what cmd.exe does
2196 in some corner cases. For example, it doesn't support the likes
2197 of "> &foo" to mean redirect to file named literally "&foo"; we
2198 do support that here, because that, too, sounds like some issue
2199 with the cmd.exe parser. Another nicety is that we support
2200 redirection targets that use file names with forward slashes,
2201 something cmd.exe doesn't -- this comes in handy since GDB
2202 file-name completion can be used when typing the command line for
2205 /* Support routines for redirecting standard handles of the inferior. */
2207 /* Parse a single redirection spec, open/duplicate the specified
2208 file/fd, and assign the appropriate value to one of the 3 standard
2209 file descriptors. */
2211 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2213 int *fd
, ref_fd
= -2;
2215 const char *fname
= redir_string
+ 1;
2216 int rc
= *redir_string
;
2231 fd
= (rc
== '2') ? err
: out
;
2232 mode
= O_WRONLY
| O_CREAT
;
2245 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2247 /* A reference to a file descriptor. */
2249 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2250 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2252 /* Don't allow redirection when open modes are incompatible. */
2253 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2254 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2261 else if (ref_fd
== 1)
2263 else if (ref_fd
== 2)
2273 fname
++; /* skip the separator space */
2274 /* If the descriptor is already open, close it. This allows
2275 multiple specs of redirections for the same stream, which is
2276 somewhat nonsensical, but still valid and supported by cmd.exe.
2277 (But cmd.exe only opens a single file in this case, the one
2278 specified by the last redirection spec on the command line.) */
2283 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2287 else if (ref_fd
== -1)
2288 *fd
= -1; /* reset to default destination */
2291 *fd
= _dup (ref_fd
);
2295 /* _open just sets a flag for O_APPEND, which won't be passed to the
2296 inferior, so we need to actually move the file pointer. */
2297 if ((mode
& O_APPEND
) != 0)
2298 _lseek (*fd
, 0L, SEEK_END
);
2302 /* Canonicalize a single redirection spec and set up the corresponding
2303 file descriptor as specified. */
2305 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2307 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2309 const char *start
= s
;
2312 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2313 if ((*start
== '>' || *start
== '1' || *start
== '2')
2317 if (*s
== '>' && *start
!= '>')
2320 else if (*start
== '0' && *s
== '<')
2322 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2325 while (isspace (*s
)) /* skip whitespace before file name */
2327 *d
++ = ' '; /* separate file name with a single space */
2330 /* Copy the file name. */
2333 /* Remove quoting characters from the file name in buf[]. */
2334 if (*s
== '"') /* could support '..' quoting here */
2338 else if (*s
== quote
)
2346 else if (*s
== '\\')
2348 if (s
[1] == '"') /* could support '..' here */
2352 else if (isspace (*s
) && !quote
)
2356 if (d
- buf
>= sizeof (buf
) - 1)
2358 errno
= ENAMETOOLONG
;
2364 /* Windows doesn't allow redirection characters in file names, so we
2365 can bail out early if they use them, or if there's no target file
2366 name after the redirection symbol. */
2367 if (d
[-1] == '>' || d
[-1] == '<')
2372 if (redir_open (buf
, inp
, out
, err
) == 0)
2377 /* Parse the command line for redirection specs and prepare the file
2378 descriptors for the 3 standard streams accordingly. */
2380 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2381 int *inp
, int *out
, int *err
)
2383 const char *s
= cmd_orig
;
2386 bool retval
= false;
2388 while (isspace (*s
))
2393 if (*s
== '"') /* could also support '..' quoting here */
2397 else if (*s
== quote
)
2400 else if (*s
== '\\')
2402 if (s
[1] == '"') /* escaped quote char */
2407 /* Process a single redirection candidate. */
2408 if (*s
== '<' || *s
== '>'
2409 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2410 || (*s
== '0' && s
[1] == '<'))
2412 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2426 #endif /* !__CYGWIN__ */
2428 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2429 EXEC_FILE is the file to run.
2430 ALLARGS is a string containing the arguments to the program.
2431 ENV is the environment vector to pass. Errors reported with error(). */
2434 windows_create_inferior (struct target_ops
*ops
, const char *exec_file
,
2435 const std::string
&origallargs
, char **in_env
,
2440 cygwin_buf_t real_path
[__PMAX
];
2441 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2442 cygwin_buf_t infcwd
[__PMAX
];
2444 cygwin_buf_t
*toexec
;
2445 cygwin_buf_t
*cygallargs
;
2447 char **old_env
= NULL
;
2451 int ostdin
, ostdout
, ostderr
;
2452 #else /* !__CYGWIN__ */
2453 char real_path
[__PMAX
];
2454 char shell
[__PMAX
]; /* Path to shell */
2456 char *args
, *allargs_copy
;
2457 size_t args_len
, allargs_len
;
2458 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2459 HANDLE tty
= INVALID_HANDLE_VALUE
;
2460 HANDLE inf_stdin
= INVALID_HANDLE_VALUE
;
2461 HANDLE inf_stdout
= INVALID_HANDLE_VALUE
;
2462 HANDLE inf_stderr
= INVALID_HANDLE_VALUE
;
2463 bool redirected
= false;
2470 #endif /* !__CYGWIN__ */
2471 const char *allargs
= origallargs
.c_str ();
2472 PROCESS_INFORMATION pi
;
2475 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2478 error (_("No executable specified, use `target exec'."));
2480 const char *inferior_cwd
= get_inferior_cwd ();
2481 std::string expanded_infcwd
;
2482 if (inferior_cwd
!= NULL
)
2484 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2485 /* Mirror slashes on inferior's cwd. */
2486 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2488 inferior_cwd
= expanded_infcwd
.c_str ();
2491 memset (&si
, 0, sizeof (si
));
2492 si
.cb
= sizeof (si
);
2495 flags
|= CREATE_NEW_PROCESS_GROUP
;
2498 windows_set_console_info (&si
, &flags
);
2503 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2504 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2505 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2506 error (_("Error starting executable: %d"), errno
);
2509 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2510 if (len
== (size_t) -1)
2511 error (_("Error starting executable: %d"), errno
);
2512 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2513 mbstowcs (cygallargs
, allargs
, len
);
2514 #else /* !__USEWIDE */
2515 cygallargs
= allargs
;
2520 sh
= getenv ("SHELL");
2523 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2524 error (_("Error starting executable via shell: %d"), errno
);
2526 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2527 + mbstowcs (NULL
, allargs
, 0) + 2;
2528 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2529 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2530 #else /* !__USEWIDE */
2531 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2532 + strlen (allargs
) + 2);
2533 cygallargs
= (char *) alloca (len
);
2534 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2535 #endif /* __USEWIDE */
2537 flags
|= DEBUG_PROCESS
;
2540 if (inferior_cwd
!= NULL
2541 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2542 infcwd
, strlen (inferior_cwd
)) < 0)
2543 error (_("Error converting inferior cwd: %d"), errno
);
2546 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2547 * sizeof (wchar_t));
2548 wcscpy (args
, toexec
);
2549 wcscat (args
, L
" ");
2550 wcscat (args
, cygallargs
);
2551 #else /* !__USEWIDE */
2552 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2553 strcpy (args
, toexec
);
2555 strcat (args
, cygallargs
);
2556 #endif /* !__USEWIDE */
2558 #ifdef CW_CVT_ENV_TO_WINENV
2559 /* First try to create a direct Win32 copy of the POSIX environment. */
2560 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2561 if (w32_env
!= (PWCHAR
) -1)
2562 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2564 /* If that fails, fall back to old method tweaking GDB's environment. */
2565 #endif /* CW_CVT_ENV_TO_WINENV */
2567 /* Reset all Win32 environment variables to avoid leftover on next run. */
2568 clear_win32_environment (environ
);
2569 /* Prepare the environment vars for CreateProcess. */
2572 cygwin_internal (CW_SYNC_WINENV
);
2576 if (!inferior_io_terminal
)
2577 tty
= ostdin
= ostdout
= ostderr
= -1;
2580 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2583 print_sys_errmsg (inferior_io_terminal
, errno
);
2584 ostdin
= ostdout
= ostderr
= -1;
2597 windows_init_thread_list ();
2598 ret
= CreateProcess (0,
2599 args
, /* command line */
2600 NULL
, /* Security */
2602 TRUE
, /* inherit handles */
2603 flags
, /* start flags */
2604 w32_env
, /* environment */
2605 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2610 /* Just free the Win32 environment, if it could be created. */
2614 /* Reset all environment variables to avoid leftover on next run. */
2615 clear_win32_environment (in_env
);
2616 /* Restore normal GDB environment variables. */
2618 cygwin_internal (CW_SYNC_WINENV
);
2631 #else /* !__CYGWIN__ */
2632 allargs_len
= strlen (allargs
);
2633 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2634 if (strpbrk (allargs_copy
, "<>") != NULL
)
2639 redirect_inferior_handles (allargs
, allargs_copy
,
2640 &fd_inp
, &fd_out
, &fd_err
);
2642 warning (_("Error in redirection: %s."), strerror (errno
));
2645 allargs_len
= strlen (allargs_copy
);
2647 /* If not all the standard streams are redirected by the command
2648 line, use inferior_io_terminal for those which aren't. */
2649 if (inferior_io_terminal
2650 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2652 SECURITY_ATTRIBUTES sa
;
2653 sa
.nLength
= sizeof(sa
);
2654 sa
.lpSecurityDescriptor
= 0;
2655 sa
.bInheritHandle
= TRUE
;
2656 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2657 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2658 if (tty
== INVALID_HANDLE_VALUE
)
2659 warning (_("Warning: Failed to open TTY %s, error %#x."),
2660 inferior_io_terminal
, (unsigned) GetLastError ());
2662 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2665 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2666 else if (tty
!= INVALID_HANDLE_VALUE
)
2669 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2671 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2672 else if (tty
!= INVALID_HANDLE_VALUE
)
2673 si
.hStdOutput
= tty
;
2675 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2677 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2678 else if (tty
!= INVALID_HANDLE_VALUE
)
2681 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2682 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2686 /* Build the command line, a space-separated list of tokens where
2687 the first token is the name of the module to be executed.
2688 To avoid ambiguities introduced by spaces in the module name,
2690 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2691 args
= (char *) alloca (args_len
);
2692 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2694 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2696 /* CreateProcess takes the environment list as a null terminated set of
2697 strings (i.e. two nulls terminate the list). */
2699 /* Get total size for env strings. */
2700 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2701 envlen
+= strlen (in_env
[i
]) + 1;
2703 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2704 env
= (char **) alloca (envsize
);
2705 memcpy (env
, in_env
, envsize
);
2706 /* Windows programs expect the environment block to be sorted. */
2707 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2709 w32env
= (char *) alloca (envlen
+ 1);
2711 /* Copy env strings into new buffer. */
2712 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2714 strcpy (temp
, env
[i
]);
2715 temp
+= strlen (temp
) + 1;
2718 /* Final nil string to terminate new env. */
2721 windows_init_thread_list ();
2722 ret
= CreateProcessA (0,
2723 args
, /* command line */
2724 NULL
, /* Security */
2726 TRUE
, /* inherit handles */
2727 flags
, /* start flags */
2728 w32env
, /* environment */
2729 inferior_cwd
, /* current directory */
2732 if (tty
!= INVALID_HANDLE_VALUE
)
2740 #endif /* !__CYGWIN__ */
2743 error (_("Error creating process %s, (error %u)."),
2744 exec_file
, (unsigned) GetLastError ());
2746 CloseHandle (pi
.hThread
);
2747 CloseHandle (pi
.hProcess
);
2749 if (useshell
&& shell
[0] != '\0')
2754 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2756 /* windows_continue (DBG_CONTINUE, -1, 0); */
2760 windows_mourn_inferior (struct target_ops
*ops
)
2762 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2763 x86_cleanup_dregs();
2764 if (open_process_used
)
2766 CHECK (CloseHandle (current_process_handle
));
2767 open_process_used
= 0;
2769 inf_child_mourn_inferior (ops
);
2772 /* Send a SIGINT to the process group. This acts just like the user typed a
2773 ^C on the controlling terminal. */
2776 windows_interrupt (struct target_ops
*self
)
2778 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2779 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2780 registers_changed (); /* refresh register state */
2783 /* Helper for windows_xfer_partial that handles memory transfers.
2784 Arguments are like target_xfer_partial. */
2786 static enum target_xfer_status
2787 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2788 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2792 DWORD lasterror
= 0;
2794 if (writebuf
!= NULL
)
2796 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2797 pulongest (len
), core_addr_to_string (memaddr
)));
2798 success
= WriteProcessMemory (current_process_handle
,
2799 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2802 lasterror
= GetLastError ();
2803 FlushInstructionCache (current_process_handle
,
2804 (LPCVOID
) (uintptr_t) memaddr
, len
);
2808 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2809 pulongest (len
), core_addr_to_string (memaddr
)));
2810 success
= ReadProcessMemory (current_process_handle
,
2811 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2814 lasterror
= GetLastError ();
2816 *xfered_len
= (ULONGEST
) done
;
2817 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2818 return TARGET_XFER_OK
;
2820 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2824 windows_kill_inferior (struct target_ops
*ops
)
2826 CHECK (TerminateProcess (current_process_handle
, 0));
2830 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2832 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2834 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2838 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2842 windows_close (struct target_ops
*self
)
2844 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2845 ptid_get_pid (inferior_ptid
)));
2848 /* Convert pid to printable format. */
2850 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2852 static char buf
[80];
2854 if (ptid_get_tid (ptid
) != 0)
2856 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2857 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2861 return normal_pid_to_str (ptid
);
2864 static enum target_xfer_status
2865 windows_xfer_shared_libraries (struct target_ops
*ops
,
2866 enum target_object object
, const char *annex
,
2867 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2868 ULONGEST offset
, ULONGEST len
,
2869 ULONGEST
*xfered_len
)
2871 struct obstack obstack
;
2877 return TARGET_XFER_E_IO
;
2879 obstack_init (&obstack
);
2880 obstack_grow_str (&obstack
, "<library-list>\n");
2881 for (so
= solib_start
.next
; so
; so
= so
->next
)
2883 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2885 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2886 (uintptr_t) li
->load_addr
,
2887 target_gdbarch (), &obstack
);
2889 obstack_grow_str0 (&obstack
, "</library-list>\n");
2891 buf
= (const char *) obstack_finish (&obstack
);
2892 len_avail
= strlen (buf
);
2893 if (offset
>= len_avail
)
2897 if (len
> len_avail
- offset
)
2898 len
= len_avail
- offset
;
2899 memcpy (readbuf
, buf
+ offset
, len
);
2902 obstack_free (&obstack
, NULL
);
2903 *xfered_len
= (ULONGEST
) len
;
2904 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2907 static enum target_xfer_status
2908 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2909 const char *annex
, gdb_byte
*readbuf
,
2910 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2911 ULONGEST
*xfered_len
)
2915 case TARGET_OBJECT_MEMORY
:
2916 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2918 case TARGET_OBJECT_LIBRARIES
:
2919 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2920 writebuf
, offset
, len
, xfered_len
);
2923 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2924 readbuf
, writebuf
, offset
, len
,
2929 /* Provide thread local base, i.e. Thread Information Block address.
2930 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2933 windows_get_tib_address (struct target_ops
*self
,
2934 ptid_t ptid
, CORE_ADDR
*addr
)
2936 windows_thread_info
*th
;
2938 th
= thread_rec (ptid_get_tid (ptid
), 0);
2943 *addr
= th
->thread_local_base
;
2949 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2951 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2954 /* Implementation of the to_thread_name method. */
2957 windows_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
2959 return thread_rec (ptid_get_tid (thr
->ptid
), 0)->name
;
2962 static struct target_ops
*
2963 windows_target (void)
2965 struct target_ops
*t
= inf_child_target ();
2967 t
->to_close
= windows_close
;
2968 t
->to_attach
= windows_attach
;
2969 t
->to_attach_no_wait
= 1;
2970 t
->to_detach
= windows_detach
;
2971 t
->to_resume
= windows_resume
;
2972 t
->to_wait
= windows_wait
;
2973 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2974 t
->to_store_registers
= windows_store_inferior_registers
;
2975 t
->to_xfer_partial
= windows_xfer_partial
;
2976 t
->to_files_info
= windows_files_info
;
2977 t
->to_kill
= windows_kill_inferior
;
2978 t
->to_create_inferior
= windows_create_inferior
;
2979 t
->to_mourn_inferior
= windows_mourn_inferior
;
2980 t
->to_thread_alive
= windows_thread_alive
;
2981 t
->to_pid_to_str
= windows_pid_to_str
;
2982 t
->to_interrupt
= windows_interrupt
;
2983 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2984 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2985 t
->to_get_tib_address
= windows_get_tib_address
;
2986 t
->to_thread_name
= windows_thread_name
;
2992 _initialize_windows_nat (void)
2994 struct target_ops
*t
;
2996 t
= windows_target ();
2998 x86_use_watchpoints (t
);
3000 x86_dr_low
.set_control
= cygwin_set_dr7
;
3001 x86_dr_low
.set_addr
= cygwin_set_dr
;
3002 x86_dr_low
.get_addr
= cygwin_get_dr
;
3003 x86_dr_low
.get_status
= cygwin_get_dr6
;
3004 x86_dr_low
.get_control
= cygwin_get_dr7
;
3006 /* x86_dr_low.debug_register_length field is set by
3007 calling x86_set_debug_register_length function
3008 in processor windows specific native file. */
3013 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3016 add_com ("signal-event", class_run
, signal_event_command
, _("\
3017 Signal a crashed process with event ID, to allow its debugging.\n\
3018 This command is needed in support of setting up GDB as JIT debugger on \
3019 MS-Windows. The command should be invoked from the GDB command line using \
3020 the '-ex' command-line option. The ID of the event that blocks the \
3021 crashed process will be supplied by the Windows JIT debugging mechanism."));
3024 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3025 Set use of shell to start subprocess."), _("\
3026 Show use of shell to start subprocess."), NULL
,
3028 NULL
, /* FIXME: i18n: */
3029 &setlist
, &showlist
);
3031 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3032 &cygwin_exceptions
, _("\
3033 Break when an exception is detected in the Cygwin DLL itself."), _("\
3034 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3036 NULL
, /* FIXME: i18n: */
3037 &setlist
, &showlist
);
3040 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3041 Set creation of new console when creating child process."), _("\
3042 Show creation of new console when creating child process."), NULL
,
3044 NULL
, /* FIXME: i18n: */
3045 &setlist
, &showlist
);
3047 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3048 Set creation of new group when creating child process."), _("\
3049 Show creation of new group when creating child process."), NULL
,
3051 NULL
, /* FIXME: i18n: */
3052 &setlist
, &showlist
);
3054 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3055 Set whether to display execution in child process."), _("\
3056 Show whether to display execution in child process."), NULL
,
3058 NULL
, /* FIXME: i18n: */
3059 &setlist
, &showlist
);
3061 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3062 Set whether to display kernel events in child process."), _("\
3063 Show whether to display kernel events in child process."), NULL
,
3065 NULL
, /* FIXME: i18n: */
3066 &setlist
, &showlist
);
3068 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3069 Set whether to display memory accesses in child process."), _("\
3070 Show whether to display memory accesses in child process."), NULL
,
3072 NULL
, /* FIXME: i18n: */
3073 &setlist
, &showlist
);
3075 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3076 &debug_exceptions
, _("\
3077 Set whether to display kernel exceptions in child process."), _("\
3078 Show whether to display kernel exceptions in child process."), NULL
,
3080 NULL
, /* FIXME: i18n: */
3081 &setlist
, &showlist
);
3083 init_w32_command_list ();
3085 add_cmd ("selector", class_info
, display_selectors
,
3086 _("Display selectors infos."),
3090 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3092 /* Pass the address ADDR to the inferior in the I'th debug register.
3093 Here we just store the address in dr array, the registers will be
3094 actually set up when windows_continue is called. */
3096 cygwin_set_dr (int i
, CORE_ADDR addr
)
3099 internal_error (__FILE__
, __LINE__
,
3100 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3102 debug_registers_changed
= 1;
3103 debug_registers_used
= 1;
3106 /* Pass the value VAL to the inferior in the DR7 debug control
3107 register. Here we just store the address in D_REGS, the watchpoint
3108 will be actually set up in windows_wait. */
3110 cygwin_set_dr7 (unsigned long val
)
3112 dr
[7] = (CORE_ADDR
) val
;
3113 debug_registers_changed
= 1;
3114 debug_registers_used
= 1;
3117 /* Get the value of debug register I from the inferior. */
3120 cygwin_get_dr (int i
)
3125 /* Get the value of the DR6 debug status register from the inferior.
3126 Here we just return the value stored in dr[6]
3127 by the last call to thread_rec for current_event.dwThreadId id. */
3128 static unsigned long
3129 cygwin_get_dr6 (void)
3131 return (unsigned long) dr
[6];
3134 /* Get the value of the DR7 debug status register from the inferior.
3135 Here we just return the value stored in dr[7] by the last call to
3136 thread_rec for current_event.dwThreadId id. */
3138 static unsigned long
3139 cygwin_get_dr7 (void)
3141 return (unsigned long) dr
[7];
3144 /* Determine if the thread referenced by "ptid" is alive
3145 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3146 it means that the thread has died. Otherwise it is assumed to be alive. */
3148 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3152 gdb_assert (ptid_get_tid (ptid
) != 0);
3153 tid
= ptid_get_tid (ptid
);
3155 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
3160 _initialize_check_for_gdb_ini (void)
3163 if (inhibit_gdbinit
)
3166 homedir
= getenv ("HOME");
3170 char *oldini
= (char *) alloca (strlen (homedir
) +
3171 sizeof ("gdb.ini") + 1);
3172 strcpy (oldini
, homedir
);
3173 p
= strchr (oldini
, '\0');
3174 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3176 strcpy (p
, "gdb.ini");
3177 if (access (oldini
, 0) == 0)
3179 int len
= strlen (oldini
);
3180 char *newini
= (char *) alloca (len
+ 2);
3182 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3183 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3184 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3189 /* Define dummy functions which always return error for the rare cases where
3190 these functions could not be found. */
3192 bad_DebugActiveProcessStop (DWORD w
)
3197 bad_DebugBreakProcess (HANDLE w
)
3202 bad_DebugSetProcessKillOnExit (BOOL w
)
3207 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3214 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3220 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3227 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3233 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3239 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3245 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3253 /* Load any functions which may not be available in ancient versions
3257 _initialize_loadable (void)
3261 #define GPA(m, func) \
3262 func = (func ## _ftype *) GetProcAddress (m, #func)
3264 hm
= LoadLibrary ("kernel32.dll");
3267 GPA (hm
, DebugActiveProcessStop
);
3268 GPA (hm
, DebugBreakProcess
);
3269 GPA (hm
, DebugSetProcessKillOnExit
);
3270 GPA (hm
, GetConsoleFontSize
);
3271 GPA (hm
, DebugActiveProcessStop
);
3272 GPA (hm
, GetCurrentConsoleFont
);
3275 /* Set variables to dummy versions of these processes if the function
3276 wasn't found in kernel32.dll. */
3277 if (!DebugBreakProcess
)
3278 DebugBreakProcess
= bad_DebugBreakProcess
;
3279 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3281 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3282 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3284 if (!GetConsoleFontSize
)
3285 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3286 if (!GetCurrentConsoleFont
)
3287 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3289 /* Load optional functions used for retrieving filename information
3290 associated with the currently debugged process or its dlls. */
3291 hm
= LoadLibrary ("psapi.dll");
3294 GPA (hm
, EnumProcessModules
);
3295 GPA (hm
, GetModuleInformation
);
3296 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3297 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3300 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3302 /* Set variables to dummy versions of these processes if the function
3303 wasn't found in psapi.dll. */
3304 EnumProcessModules
= bad_EnumProcessModules
;
3305 GetModuleInformation
= bad_GetModuleInformation
;
3306 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3307 /* This will probably fail on Windows 9x/Me. Let the user know
3308 that we're missing some functionality. */
3310 cannot automatically find executable file or library to read symbols.\n\
3311 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3314 hm
= LoadLibrary ("advapi32.dll");
3317 GPA (hm
, OpenProcessToken
);
3318 GPA (hm
, LookupPrivilegeValueA
);
3319 GPA (hm
, AdjustTokenPrivileges
);
3320 /* Only need to set one of these since if OpenProcessToken fails nothing
3322 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3323 || !AdjustTokenPrivileges
)
3324 OpenProcessToken
= bad_OpenProcessToken
;