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>
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
, ptid_t
);
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
= get_regcache_arch (regcache
);
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 (get_regcache_arch (regcache
)); 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 struct 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). */
760 handle_load_dll (void *dummy
)
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
)));
787 windows_free_so (struct so_list
*so
)
789 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
795 /* Handle a DLL unload event.
796 Return 1 if successful, or zero otherwise.
798 This function assumes that this event did not occur during inferior
799 initialization, where their event info may be incomplete (see
800 do_initial_windows_stuff and windows_add_all_dlls for more info
801 on how we handle DLL loading during that phase). */
804 handle_unload_dll (void *dummy
)
806 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
809 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
811 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
813 if (li_next
->load_addr
== lpBaseOfDll
)
815 struct so_list
*sodel
= so
->next
;
817 so
->next
= sodel
->next
;
820 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
822 windows_free_so (sodel
);
827 /* We did not find any DLL that was previously loaded at this address,
828 so register a complaint. We do not report an error, because we have
829 observed that this may be happening under some circumstances. For
830 instance, running 32bit applications on x64 Windows causes us to receive
831 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
832 events are apparently caused by the WOW layer, the interface between
833 32bit and 64bit worlds). */
834 complaint (&symfile_complaints
, _("dll starting at %s not found."),
835 host_address_to_string (lpBaseOfDll
));
840 /* Clear list of loaded DLLs. */
842 windows_clear_solib (void)
844 solib_start
.next
= NULL
;
845 solib_end
= &solib_start
;
849 signal_event_command (char *args
, int from_tty
)
851 uintptr_t event_id
= 0;
852 char *endargs
= NULL
;
855 error (_("signal-event requires an argument (integer event id)"));
857 event_id
= strtoumax (args
, &endargs
, 10);
859 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
860 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
861 error (_("Failed to convert `%s' to event id"), args
);
863 SetEvent ((HANDLE
) event_id
);
864 CloseHandle ((HANDLE
) event_id
);
867 /* Handle DEBUG_STRING output from child process.
868 Cygwin prepends its messages with a "cygwin:". Interpret this as
869 a Cygwin signal. Otherwise just print the string as a warning. */
871 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
876 if (!target_read_string
877 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
881 else if (!startswith (s
, _CYGWIN_SIGNAL_STRING
))
884 if (!startswith (s
, "cYg"))
887 char *p
= strchr (s
, '\0');
889 if (p
> s
&& *--p
== '\n')
897 /* Got a cygwin signal marker. A cygwin signal is followed by
898 the signal number itself and then optionally followed by the
899 thread id and address to saved context within the DLL. If
900 these are supplied, then the given thread is assumed to have
901 issued the signal and the context from the thread is assumed
902 to be stored at the given address in the inferior. Tell gdb
903 to treat this like a real signal. */
905 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
906 gdb_signal gotasig
= gdb_signal_from_host (sig
);
908 ourstatus
->value
.sig
= gotasig
;
914 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
915 retval
= strtoul (p
, &p
, 0);
917 retval
= main_thread_id
;
918 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
919 && ReadProcessMemory (current_process_handle
, x
,
921 __COPY_CONTEXT_SIZE
, &n
)
922 && n
== __COPY_CONTEXT_SIZE
)
923 have_saved_context
= 1;
934 display_selector (HANDLE thread
, DWORD sel
)
937 if (GetThreadSelectorEntry (thread
, sel
, &info
))
940 printf_filtered ("0x%03x: ", (unsigned) sel
);
941 if (!info
.HighWord
.Bits
.Pres
)
943 puts_filtered ("Segment not present\n");
946 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
947 (info
.HighWord
.Bits
.BaseMid
<< 16)
949 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
950 if (info
.HighWord
.Bits
.Granularity
)
951 limit
= (limit
<< 12) | 0xfff;
952 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
953 if (info
.HighWord
.Bits
.Default_Big
)
954 puts_filtered(" 32-bit ");
956 puts_filtered(" 16-bit ");
957 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
960 puts_filtered ("Data (Read-Only, Exp-up");
963 puts_filtered ("Data (Read/Write, Exp-up");
966 puts_filtered ("Unused segment (");
969 puts_filtered ("Data (Read/Write, Exp-down");
972 puts_filtered ("Code (Exec-Only, N.Conf");
975 puts_filtered ("Code (Exec/Read, N.Conf");
978 puts_filtered ("Code (Exec-Only, Conf");
981 puts_filtered ("Code (Exec/Read, Conf");
984 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
986 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
987 puts_filtered(", N.Acc");
988 puts_filtered (")\n");
989 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
990 puts_filtered("System selector ");
991 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
992 if (info
.HighWord
.Bits
.Granularity
)
993 puts_filtered ("Page granular.\n");
995 puts_filtered ("Byte granular.\n");
1000 DWORD err
= GetLastError ();
1001 if (err
== ERROR_NOT_SUPPORTED
)
1002 printf_filtered ("Function not supported\n");
1004 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1010 display_selectors (char * args
, int from_tty
)
1012 if (!current_thread
)
1014 puts_filtered ("Impossible to display selectors now.\n");
1020 puts_filtered ("Selector $cs\n");
1021 display_selector (current_thread
->h
,
1022 current_thread
->context
.SegCs
);
1023 puts_filtered ("Selector $ds\n");
1024 display_selector (current_thread
->h
,
1025 current_thread
->context
.SegDs
);
1026 puts_filtered ("Selector $es\n");
1027 display_selector (current_thread
->h
,
1028 current_thread
->context
.SegEs
);
1029 puts_filtered ("Selector $ss\n");
1030 display_selector (current_thread
->h
,
1031 current_thread
->context
.SegSs
);
1032 puts_filtered ("Selector $fs\n");
1033 display_selector (current_thread
->h
,
1034 current_thread
->context
.SegFs
);
1035 puts_filtered ("Selector $gs\n");
1036 display_selector (current_thread
->h
,
1037 current_thread
->context
.SegGs
);
1042 sel
= parse_and_eval_long (args
);
1043 printf_filtered ("Selector \"%s\"\n",args
);
1044 display_selector (current_thread
->h
, sel
);
1048 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1049 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1050 host_address_to_string (\
1051 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1053 static handle_exception_result
1054 handle_exception (struct target_waitstatus
*ourstatus
)
1056 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1057 DWORD code
= rec
->ExceptionCode
;
1058 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1060 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1062 /* Record the context of the current thread. */
1063 thread_rec (current_event
.dwThreadId
, -1);
1067 case EXCEPTION_ACCESS_VIOLATION
:
1068 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1069 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1072 /* See if the access violation happened within the cygwin DLL
1073 itself. Cygwin uses a kind of exception handling to deal
1074 with passed-in invalid addresses. gdb should not treat
1075 these as real SEGVs since they will be silently handled by
1076 cygwin. A real SEGV will (theoretically) be caught by
1077 cygwin later in the process and will be sent as a
1078 cygwin-specific-signal. So, ignore SEGVs if they show up
1079 within the text segment of the DLL itself. */
1081 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1083 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1084 && addr
< cygwin_load_end
))
1085 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1086 && startswith (fn
, "KERNEL32!IsBad")))
1087 return HANDLE_EXCEPTION_UNHANDLED
;
1091 case STATUS_STACK_OVERFLOW
:
1092 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1093 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1095 case STATUS_FLOAT_DENORMAL_OPERAND
:
1096 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1097 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1099 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1100 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1101 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1103 case STATUS_FLOAT_INEXACT_RESULT
:
1104 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1105 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1107 case STATUS_FLOAT_INVALID_OPERATION
:
1108 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1109 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1111 case STATUS_FLOAT_OVERFLOW
:
1112 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1113 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1115 case STATUS_FLOAT_STACK_CHECK
:
1116 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1117 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1119 case STATUS_FLOAT_UNDERFLOW
:
1120 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1121 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1123 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1124 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1125 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1127 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1128 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1129 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1131 case STATUS_INTEGER_OVERFLOW
:
1132 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1133 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1135 case EXCEPTION_BREAKPOINT
:
1136 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1137 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1140 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1141 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1143 case DBG_CONTROL_BREAK
:
1144 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1145 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1147 case EXCEPTION_SINGLE_STEP
:
1148 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1149 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1151 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1152 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1153 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1155 case EXCEPTION_PRIV_INSTRUCTION
:
1156 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1157 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1159 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1160 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1161 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1163 case MS_VC_EXCEPTION
:
1164 if (rec
->NumberParameters
>= 3
1165 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1167 DWORD named_thread_id
;
1168 windows_thread_info
*named_thread
;
1169 CORE_ADDR thread_name_target
;
1171 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1173 thread_name_target
= rec
->ExceptionInformation
[1];
1174 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1176 if (named_thread_id
== (DWORD
) -1)
1177 named_thread_id
= current_event
.dwThreadId
;
1179 named_thread
= thread_rec (named_thread_id
, 0);
1180 if (named_thread
!= NULL
)
1182 int thread_name_len
;
1185 thread_name_len
= target_read_string (thread_name_target
,
1186 &thread_name
, 1025, NULL
);
1187 if (thread_name_len
> 0)
1189 thread_name
[thread_name_len
- 1] = '\0';
1190 xfree (named_thread
->name
);
1191 named_thread
->name
= thread_name
;
1194 xfree (thread_name
);
1196 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1197 result
= HANDLE_EXCEPTION_IGNORED
;
1200 /* treat improperly formed exception as unknown, fallthrough */
1202 /* Treat unhandled first chance exceptions specially. */
1203 if (current_event
.u
.Exception
.dwFirstChance
)
1204 return HANDLE_EXCEPTION_UNHANDLED
;
1205 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1206 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1207 host_address_to_string (
1208 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1209 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1213 last_sig
= ourstatus
->value
.sig
;
1217 /* Resume thread specified by ID, or all artificially suspended
1218 threads, if we are continuing execution. KILLED non-zero means we
1219 have killed the inferior, so we should ignore weird errors due to
1220 threads shutting down. */
1222 windows_continue (DWORD continue_status
, int id
, int killed
)
1225 windows_thread_info
*th
;
1228 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1229 (unsigned) current_event
.dwProcessId
,
1230 (unsigned) current_event
.dwThreadId
,
1231 continue_status
== DBG_CONTINUE
?
1232 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1234 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1235 if ((id
== -1 || id
== (int) th
->id
)
1238 if (debug_registers_changed
)
1240 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1241 th
->context
.Dr0
= dr
[0];
1242 th
->context
.Dr1
= dr
[1];
1243 th
->context
.Dr2
= dr
[2];
1244 th
->context
.Dr3
= dr
[3];
1245 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1246 th
->context
.Dr7
= dr
[7];
1248 if (th
->context
.ContextFlags
)
1252 if (GetExitCodeThread (th
->h
, &ec
)
1253 && ec
== STILL_ACTIVE
)
1255 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1260 th
->context
.ContextFlags
= 0;
1262 if (th
->suspended
> 0)
1263 (void) ResumeThread (th
->h
);
1267 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1268 current_event
.dwThreadId
,
1272 error (_("Failed to resume program execution"
1273 " (ContinueDebugEvent failed, error %u)"),
1274 (unsigned int) GetLastError ());
1276 debug_registers_changed
= 0;
1280 /* Called in pathological case where Windows fails to send a
1281 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1283 fake_create_process (void)
1285 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1286 current_event
.dwProcessId
);
1287 if (current_process_handle
!= NULL
)
1288 open_process_used
= 1;
1291 error (_("OpenProcess call failed, GetLastError = %u"),
1292 (unsigned) GetLastError ());
1293 /* We can not debug anything in that case. */
1295 main_thread_id
= current_event
.dwThreadId
;
1296 current_thread
= windows_add_thread (
1297 ptid_build (current_event
.dwProcessId
, 0,
1298 current_event
.dwThreadId
),
1299 current_event
.u
.CreateThread
.hThread
,
1300 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1301 return main_thread_id
;
1305 windows_resume (struct target_ops
*ops
,
1306 ptid_t ptid
, int step
, enum gdb_signal sig
)
1308 windows_thread_info
*th
;
1309 DWORD continue_status
= DBG_CONTINUE
;
1311 /* A specific PTID means `step only this thread id'. */
1312 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1314 /* If we're continuing all threads, it's the current inferior that
1315 should be handled specially. */
1317 ptid
= inferior_ptid
;
1319 if (sig
!= GDB_SIGNAL_0
)
1321 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1323 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1325 else if (sig
== last_sig
)
1326 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1329 /* This code does not seem to work, because
1330 the kernel does probably not consider changes in the ExceptionRecord
1331 structure when passing the exception to the inferior.
1332 Note that this seems possible in the exception handler itself. */
1335 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1336 if (xlate
[i
].us
== sig
)
1338 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1340 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1343 if (continue_status
== DBG_CONTINUE
)
1345 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1349 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1353 last_sig
= GDB_SIGNAL_0
;
1355 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1356 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1358 /* Get context for currently selected thread. */
1359 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1364 /* Single step by setting t bit. */
1365 struct regcache
*regcache
= get_current_regcache ();
1366 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1367 windows_fetch_inferior_registers (ops
, regcache
,
1368 gdbarch_ps_regnum (gdbarch
));
1369 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1372 if (th
->context
.ContextFlags
)
1374 if (debug_registers_changed
)
1376 th
->context
.Dr0
= dr
[0];
1377 th
->context
.Dr1
= dr
[1];
1378 th
->context
.Dr2
= dr
[2];
1379 th
->context
.Dr3
= dr
[3];
1380 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1381 th
->context
.Dr7
= dr
[7];
1383 CHECK (SetThreadContext (th
->h
, &th
->context
));
1384 th
->context
.ContextFlags
= 0;
1388 /* Allow continuing with the same signal that interrupted us.
1389 Otherwise complain. */
1392 windows_continue (continue_status
, -1, 0);
1394 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1397 /* Ctrl-C handler used when the inferior is not run in the same console. The
1398 handler is in charge of interrupting the inferior using DebugBreakProcess.
1399 Note that this function is not available prior to Windows XP. In this case
1400 we emit a warning. */
1402 ctrl_c_handler (DWORD event_type
)
1404 const int attach_flag
= current_inferior ()->attach_flag
;
1406 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1407 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1410 /* If the inferior and the debugger share the same console, do nothing as
1411 the inferior has also received the Ctrl-C event. */
1412 if (!new_console
&& !attach_flag
)
1415 if (!DebugBreakProcess (current_process_handle
))
1416 warning (_("Could not interrupt program. "
1417 "Press Ctrl-c in the program console."));
1419 /* Return true to tell that Ctrl-C has been handled. */
1423 /* Get the next event from the child. Returns a non-zero thread id if the event
1424 requires handling by WFI (or whatever). */
1426 get_windows_debug_event (struct target_ops
*ops
,
1427 int pid
, struct target_waitstatus
*ourstatus
)
1430 DWORD continue_status
, event_code
;
1431 windows_thread_info
*th
;
1432 static windows_thread_info dummy_thread_info
;
1433 DWORD thread_id
= 0;
1435 last_sig
= GDB_SIGNAL_0
;
1437 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1441 continue_status
= DBG_CONTINUE
;
1443 event_code
= current_event
.dwDebugEventCode
;
1444 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1446 have_saved_context
= 0;
1450 case CREATE_THREAD_DEBUG_EVENT
:
1451 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1452 (unsigned) current_event
.dwProcessId
,
1453 (unsigned) current_event
.dwThreadId
,
1454 "CREATE_THREAD_DEBUG_EVENT"));
1455 if (saw_create
!= 1)
1457 struct inferior
*inf
;
1458 inf
= find_inferior_pid (current_event
.dwProcessId
);
1459 if (!saw_create
&& inf
->attach_flag
)
1461 /* Kludge around a Windows bug where first event is a create
1462 thread event. Caused when attached process does not have
1464 thread_id
= fake_create_process ();
1470 /* Record the existence of this thread. */
1471 thread_id
= current_event
.dwThreadId
;
1472 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1473 current_event
.dwThreadId
),
1474 current_event
.u
.CreateThread
.hThread
,
1475 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1479 case EXIT_THREAD_DEBUG_EVENT
:
1480 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1481 (unsigned) current_event
.dwProcessId
,
1482 (unsigned) current_event
.dwThreadId
,
1483 "EXIT_THREAD_DEBUG_EVENT"));
1485 if (current_event
.dwThreadId
!= main_thread_id
)
1487 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1488 current_event
.dwThreadId
),
1489 current_event
.u
.ExitThread
.dwExitCode
);
1490 th
= &dummy_thread_info
;
1494 case CREATE_PROCESS_DEBUG_EVENT
:
1495 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1496 (unsigned) current_event
.dwProcessId
,
1497 (unsigned) current_event
.dwThreadId
,
1498 "CREATE_PROCESS_DEBUG_EVENT"));
1499 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1500 if (++saw_create
!= 1)
1503 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1505 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1508 main_thread_id
= current_event
.dwThreadId
;
1509 /* Add the main thread. */
1510 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1511 current_event
.dwThreadId
),
1512 current_event
.u
.CreateProcessInfo
.hThread
,
1513 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1514 thread_id
= current_event
.dwThreadId
;
1517 case EXIT_PROCESS_DEBUG_EVENT
:
1518 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1519 (unsigned) current_event
.dwProcessId
,
1520 (unsigned) current_event
.dwThreadId
,
1521 "EXIT_PROCESS_DEBUG_EVENT"));
1522 if (!windows_initialization_done
)
1524 target_terminal::ours ();
1525 target_mourn_inferior (inferior_ptid
);
1526 error (_("During startup program exited with code 0x%x."),
1527 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1529 else if (saw_create
== 1)
1531 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1532 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1533 thread_id
= main_thread_id
;
1537 case LOAD_DLL_DEBUG_EVENT
:
1538 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1539 (unsigned) current_event
.dwProcessId
,
1540 (unsigned) current_event
.dwThreadId
,
1541 "LOAD_DLL_DEBUG_EVENT"));
1542 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1543 if (saw_create
!= 1 || ! windows_initialization_done
)
1545 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1546 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1547 ourstatus
->value
.integer
= 0;
1548 thread_id
= main_thread_id
;
1551 case UNLOAD_DLL_DEBUG_EVENT
:
1552 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1553 (unsigned) current_event
.dwProcessId
,
1554 (unsigned) current_event
.dwThreadId
,
1555 "UNLOAD_DLL_DEBUG_EVENT"));
1556 if (saw_create
!= 1 || ! windows_initialization_done
)
1558 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1559 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1560 ourstatus
->value
.integer
= 0;
1561 thread_id
= main_thread_id
;
1564 case EXCEPTION_DEBUG_EVENT
:
1565 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1566 (unsigned) current_event
.dwProcessId
,
1567 (unsigned) current_event
.dwThreadId
,
1568 "EXCEPTION_DEBUG_EVENT"));
1569 if (saw_create
!= 1)
1571 switch (handle_exception (ourstatus
))
1573 case HANDLE_EXCEPTION_UNHANDLED
:
1575 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1577 case HANDLE_EXCEPTION_HANDLED
:
1578 thread_id
= current_event
.dwThreadId
;
1580 case HANDLE_EXCEPTION_IGNORED
:
1581 continue_status
= DBG_CONTINUE
;
1586 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1587 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1588 (unsigned) current_event
.dwProcessId
,
1589 (unsigned) current_event
.dwThreadId
,
1590 "OUTPUT_DEBUG_STRING_EVENT"));
1591 if (saw_create
!= 1)
1593 thread_id
= handle_output_debug_string (ourstatus
);
1597 if (saw_create
!= 1)
1599 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1600 (unsigned) current_event
.dwProcessId
,
1601 (unsigned) current_event
.dwThreadId
);
1602 printf_unfiltered (" unknown event code %u\n",
1603 (unsigned) current_event
.dwDebugEventCode
);
1607 if (!thread_id
|| saw_create
!= 1)
1609 CHECK (windows_continue (continue_status
, -1, 0));
1613 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1615 current_thread
= th
;
1616 if (!current_thread
)
1617 current_thread
= thread_rec (thread_id
, TRUE
);
1624 /* Wait for interesting events to occur in the target process. */
1626 windows_wait (struct target_ops
*ops
,
1627 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1631 target_terminal::ours ();
1633 /* We loop when we get a non-standard exception rather than return
1634 with a SPURIOUS because resume can try and step or modify things,
1635 which needs a current_thread->h. But some of these exceptions mark
1636 the birth or death of threads, which mean that the current thread
1637 isn't necessarily what you think it is. */
1643 /* If the user presses Ctrl-c while the debugger is waiting
1644 for an event, he expects the debugger to interrupt his program
1645 and to get the prompt back. There are two possible situations:
1647 - The debugger and the program do not share the console, in
1648 which case the Ctrl-c event only reached the debugger.
1649 In that case, the ctrl_c handler will take care of interrupting
1650 the inferior. Note that this case is working starting with
1651 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1654 - The debugger and the program share the same console, in which
1655 case both debugger and inferior will receive the Ctrl-c event.
1656 In that case the ctrl_c handler will ignore the event, as the
1657 Ctrl-c event generated inside the inferior will trigger the
1658 expected debug event.
1660 FIXME: brobecker/2008-05-20: If the inferior receives the
1661 signal first and the delay until GDB receives that signal
1662 is sufficiently long, GDB can sometimes receive the SIGINT
1663 after we have unblocked the CTRL+C handler. This would
1664 lead to the debugger stopping prematurely while handling
1665 the new-thread event that comes with the handling of the SIGINT
1666 inside the inferior, and then stop again immediately when
1667 the user tries to resume the execution in the inferior.
1668 This is a classic race that we should try to fix one day. */
1669 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1670 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1671 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1674 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1679 if (deprecated_ui_loop_hook
!= NULL
)
1680 detach
= deprecated_ui_loop_hook (0);
1683 windows_kill_inferior (ops
);
1688 /* Iterate over all DLLs currently mapped by our inferior, and
1689 add them to our list of solibs. */
1692 windows_add_all_dlls (void)
1695 HMODULE dummy_hmodule
;
1700 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1701 sizeof (HMODULE
), &cb_needed
) == 0)
1707 hmodules
= (HMODULE
*) alloca (cb_needed
);
1708 if (EnumProcessModules (current_process_handle
, hmodules
,
1709 cb_needed
, &cb_needed
) == 0)
1712 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1716 wchar_t dll_name
[__PMAX
];
1719 char dll_name
[__PMAX
];
1722 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1723 &mi
, sizeof (mi
)) == 0)
1725 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1726 dll_name
, sizeof (dll_name
)) == 0)
1729 wcstombs (name
, dll_name
, __PMAX
);
1734 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1735 solib_end
= solib_end
->next
;
1740 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1743 struct inferior
*inf
;
1744 struct thread_info
*tp
;
1746 last_sig
= GDB_SIGNAL_0
;
1748 exception_count
= 0;
1749 open_process_used
= 0;
1750 debug_registers_changed
= 0;
1751 debug_registers_used
= 0;
1752 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1755 cygwin_load_start
= cygwin_load_end
= 0;
1757 current_event
.dwProcessId
= pid
;
1758 memset (¤t_event
, 0, sizeof (current_event
));
1759 if (!target_is_pushed (ops
))
1761 disable_breakpoints_in_shlibs ();
1762 windows_clear_solib ();
1763 clear_proceed_status (0);
1764 init_wait_for_inferior ();
1766 inf
= current_inferior ();
1767 inferior_appeared (inf
, pid
);
1768 inf
->attach_flag
= attaching
;
1770 /* Make the new process the current inferior, so terminal handling
1771 can rely on it. When attaching, we don't know about any thread
1772 id here, but that's OK --- nothing should be referencing the
1773 current thread until we report an event out of windows_wait. */
1774 inferior_ptid
= pid_to_ptid (pid
);
1776 target_terminal::init ();
1777 target_terminal::inferior ();
1779 windows_initialization_done
= 0;
1783 struct target_waitstatus status
;
1785 windows_wait (ops
, minus_one_ptid
, &status
, 0);
1787 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1789 if (status
.kind
!= TARGET_WAITKIND_LOADED
1790 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1793 windows_resume (ops
, minus_one_ptid
, 0, GDB_SIGNAL_0
);
1796 /* Now that the inferior has been started and all DLLs have been mapped,
1797 we can iterate over all DLLs and load them in.
1799 We avoid doing it any earlier because, on certain versions of Windows,
1800 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1801 we have seen on Windows 8.1 that the ntdll.dll load event does not
1802 include the DLL name, preventing us from creating an associated SO.
1803 A possible explanation is that ntdll.dll might be mapped before
1804 the SO info gets created by the Windows system -- ntdll.dll is
1805 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1806 do not seem to suffer from that problem.
1808 Rather than try to work around this sort of issue, it is much
1809 simpler to just ignore DLL load/unload events during the startup
1810 phase, and then process them all in one batch now. */
1811 windows_add_all_dlls ();
1813 windows_initialization_done
= 1;
1817 /* Try to set or remove a user privilege to the current process. Return -1
1818 if that fails, the previous setting of that privilege otherwise.
1820 This code is copied from the Cygwin source code and rearranged to allow
1821 dynamically loading of the needed symbols from advapi32 which is only
1822 available on NT/2K/XP. */
1824 set_process_privilege (const char *privilege
, BOOL enable
)
1826 HANDLE token_hdl
= NULL
;
1828 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1832 if (!OpenProcessToken (GetCurrentProcess (),
1833 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1837 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1840 new_priv
.PrivilegeCount
= 1;
1841 new_priv
.Privileges
[0].Luid
= restore_priv
;
1842 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1844 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1845 sizeof orig_priv
, &orig_priv
, &size
))
1848 /* Disabled, otherwise every `attach' in an unprivileged user session
1849 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1850 windows_attach(). */
1851 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1852 be enabled. GetLastError () returns an correct error code, though. */
1853 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1857 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1861 CloseHandle (token_hdl
);
1866 /* Attach to process PID, then initialize for debugging it. */
1868 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1873 pid
= parse_pid_to_attach (args
);
1875 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1877 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1878 printf_unfiltered ("This can cause attach to "
1879 "fail on Windows NT/2K/XP\n");
1882 windows_init_thread_list ();
1883 ok
= DebugActiveProcess (pid
);
1889 /* Try fall back to Cygwin pid. */
1890 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1893 ok
= DebugActiveProcess (pid
);
1898 error (_("Can't attach to process."));
1900 DebugSetProcessKillOnExit (FALSE
);
1904 char *exec_file
= (char *) get_exec_file (0);
1907 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1908 target_pid_to_str (pid_to_ptid (pid
)));
1910 printf_unfiltered ("Attaching to %s\n",
1911 target_pid_to_str (pid_to_ptid (pid
)));
1913 gdb_flush (gdb_stdout
);
1916 do_initial_windows_stuff (ops
, pid
, 1);
1917 target_terminal::ours ();
1921 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1925 ptid_t ptid
= minus_one_ptid
;
1926 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1928 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1930 error (_("Can't detach process %u (error %u)"),
1931 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1934 DebugSetProcessKillOnExit (FALSE
);
1936 if (detached
&& from_tty
)
1938 const char *exec_file
= get_exec_file (0);
1941 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1942 (unsigned) current_event
.dwProcessId
);
1943 gdb_flush (gdb_stdout
);
1946 x86_cleanup_dregs ();
1947 inferior_ptid
= null_ptid
;
1948 detach_inferior (current_event
.dwProcessId
);
1950 inf_child_maybe_unpush_target (ops
);
1953 /* Try to determine the executable filename.
1955 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1957 Upon success, the filename is stored inside EXE_NAME_RET, and
1958 this function returns nonzero.
1960 Otherwise, this function returns zero and the contents of
1961 EXE_NAME_RET is undefined. */
1964 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1971 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1972 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1975 /* We know the executable is always first in the list of modules,
1976 which we just fetched. So no need to fetch more. */
1980 /* Cygwin prefers that the path be in /x/y/z format, so extract
1981 the filename into a temporary buffer first, and then convert it
1982 to POSIX format into the destination buffer. */
1983 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1985 len
= GetModuleFileNameEx (current_process_handle
,
1986 dh_buf
, pathbuf
, exe_name_max_len
);
1988 error (_("Error getting executable filename: %u."),
1989 (unsigned) GetLastError ());
1990 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1991 exe_name_max_len
) < 0)
1992 error (_("Error converting executable filename to POSIX: %d."), errno
);
1995 len
= GetModuleFileNameEx (current_process_handle
,
1996 dh_buf
, exe_name_ret
, exe_name_max_len
);
1998 error (_("Error getting executable filename: %u."),
1999 (unsigned) GetLastError ());
2002 return 1; /* success */
2005 /* The pid_to_exec_file target_ops method for this platform. */
2008 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
2010 static char path
[__PMAX
];
2012 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2014 char procexe
[sizeof ("/proc/4294967295/exe")];
2016 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2017 nchars
= readlink (procexe
, path
, sizeof(path
));
2018 if (nchars
> 0 && nchars
< sizeof (path
))
2020 path
[nchars
] = '\0'; /* Got it */
2025 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2026 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2027 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2033 /* Print status information about what we're accessing. */
2036 windows_files_info (struct target_ops
*ignore
)
2038 struct inferior
*inf
= current_inferior ();
2040 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2041 inf
->attach_flag
? "attached" : "child",
2042 target_pid_to_str (inferior_ptid
));
2045 /* Modify CreateProcess parameters for use of a new separate console.
2047 *FLAGS: DWORD parameter for general process creation flags.
2048 *SI: STARTUPINFO structure, for which the console window size and
2049 console buffer size is filled in if GDB is running in a console.
2050 to create the new console.
2051 The size of the used font is not available on all versions of
2052 Windows OS. Furthermore, the current font might not be the default
2053 font, but this is still better than before.
2054 If the windows and buffer sizes are computed,
2055 SI->DWFLAGS is changed so that this information is used
2056 by CreateProcess function. */
2059 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2061 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2062 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2064 if (hconsole
!= INVALID_HANDLE_VALUE
)
2066 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2068 CONSOLE_FONT_INFO cfi
;
2070 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2071 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2072 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2073 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2074 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2076 si
->dwXSize
*= font_size
.X
;
2080 si
->dwYSize
*= font_size
.Y
;
2083 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2084 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2085 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2087 *flags
|= CREATE_NEW_CONSOLE
;
2091 /* Function called by qsort to sort environment strings. */
2094 envvar_cmp (const void *a
, const void *b
)
2096 const char **p
= (const char **) a
;
2097 const char **q
= (const char **) b
;
2098 return strcasecmp (*p
, *q
);
2104 clear_win32_environment (char **env
)
2108 wchar_t *copy
= NULL
, *equalpos
;
2110 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2112 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2113 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2114 mbstowcs (copy
, env
[i
], len
);
2115 equalpos
= wcschr (copy
, L
'=');
2118 SetEnvironmentVariableW (copy
, NULL
);
2126 /* Redirection of inferior I/O streams for native MS-Windows programs.
2127 Unlike on Unix, where this is handled by invoking the inferior via
2128 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2130 The official documentation of the cmd.exe redirection features is here:
2132 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2134 (That page talks about Windows XP, but there's no newer
2135 documentation, so we assume later versions of cmd.exe didn't change
2138 Caveat: the documentation on that page seems to include a few lies.
2139 For example, it describes strange constructs 1<&2 and 2<&1, which
2140 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2141 think the cmd.exe parser of the redirection symbols simply doesn't
2142 care about the < vs > distinction in these cases. Therefore, the
2143 supported features are explicitly documented below.
2145 The emulation below aims at supporting all the valid use cases
2146 supported by cmd.exe, which include:
2148 < FILE redirect standard input from FILE
2149 0< FILE redirect standard input from FILE
2150 <&N redirect standard input from file descriptor N
2151 0<&N redirect standard input from file descriptor N
2152 > FILE redirect standard output to FILE
2153 >> FILE append standard output to FILE
2154 1>> FILE append standard output to FILE
2155 >&N redirect standard output to file descriptor N
2156 1>&N redirect standard output to file descriptor N
2157 >>&N append standard output to file descriptor N
2158 1>>&N append standard output to file descriptor N
2159 2> FILE redirect standard error to FILE
2160 2>> FILE append standard error to FILE
2161 2>&N redirect standard error to file descriptor N
2162 2>>&N append standard error to file descriptor N
2164 Note that using N > 2 in the above construct is supported, but
2165 requires that the corresponding file descriptor be open by some
2166 means elsewhere or outside GDB. Also note that using ">&0" or
2167 "<&2" will generally fail, because the file descriptor redirected
2168 from is normally open in an incompatible mode (e.g., FD 0 is open
2169 for reading only). IOW, use of such tricks is not recommended;
2170 you are on your own.
2172 We do NOT support redirection of file descriptors above 2, as in
2173 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2174 that needs special handling in the startup code that MinGW
2175 doesn't have). Pipes are also not supported.
2177 As for invalid use cases, where the redirection contains some
2178 error, the emulation below will detect that and produce some
2179 error and/or failure. But the behavior in those cases is not
2180 bug-for-bug compatible with what cmd.exe does in those cases.
2181 That's because what cmd.exe does then is not well defined, and
2182 seems to be a side effect of the cmd.exe parsing of the command
2183 line more than anything else. For example, try redirecting to an
2184 invalid file name, as in "> foo:bar".
2186 There are also minor syntactic deviations from what cmd.exe does
2187 in some corner cases. For example, it doesn't support the likes
2188 of "> &foo" to mean redirect to file named literally "&foo"; we
2189 do support that here, because that, too, sounds like some issue
2190 with the cmd.exe parser. Another nicety is that we support
2191 redirection targets that use file names with forward slashes,
2192 something cmd.exe doesn't -- this comes in handy since GDB
2193 file-name completion can be used when typing the command line for
2196 /* Support routines for redirecting standard handles of the inferior. */
2198 /* Parse a single redirection spec, open/duplicate the specified
2199 file/fd, and assign the appropriate value to one of the 3 standard
2200 file descriptors. */
2202 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2204 int *fd
, ref_fd
= -2;
2206 const char *fname
= redir_string
+ 1;
2207 int rc
= *redir_string
;
2222 fd
= (rc
== '2') ? err
: out
;
2223 mode
= O_WRONLY
| O_CREAT
;
2236 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2238 /* A reference to a file descriptor. */
2240 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2241 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2243 /* Don't allow redirection when open modes are incompatible. */
2244 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2245 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2252 else if (ref_fd
== 1)
2254 else if (ref_fd
== 2)
2264 fname
++; /* skip the separator space */
2265 /* If the descriptor is already open, close it. This allows
2266 multiple specs of redirections for the same stream, which is
2267 somewhat nonsensical, but still valid and supported by cmd.exe.
2268 (But cmd.exe only opens a single file in this case, the one
2269 specified by the last redirection spec on the command line.) */
2274 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2278 else if (ref_fd
== -1)
2279 *fd
= -1; /* reset to default destination */
2282 *fd
= _dup (ref_fd
);
2286 /* _open just sets a flag for O_APPEND, which won't be passed to the
2287 inferior, so we need to actually move the file pointer. */
2288 if ((mode
& O_APPEND
) != 0)
2289 _lseek (*fd
, 0L, SEEK_END
);
2293 /* Canonicalize a single redirection spec and set up the corresponding
2294 file descriptor as specified. */
2296 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2298 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2300 const char *start
= s
;
2303 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2304 if ((*start
== '>' || *start
== '1' || *start
== '2')
2308 if (*s
== '>' && *start
!= '>')
2311 else if (*start
== '0' && *s
== '<')
2313 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2316 while (isspace (*s
)) /* skip whitespace before file name */
2318 *d
++ = ' '; /* separate file name with a single space */
2321 /* Copy the file name. */
2324 /* Remove quoting characters from the file name in buf[]. */
2325 if (*s
== '"') /* could support '..' quoting here */
2329 else if (*s
== quote
)
2337 else if (*s
== '\\')
2339 if (s
[1] == '"') /* could support '..' here */
2343 else if (isspace (*s
) && !quote
)
2347 if (d
- buf
>= sizeof (buf
) - 1)
2349 errno
= ENAMETOOLONG
;
2355 /* Windows doesn't allow redirection characters in file names, so we
2356 can bail out early if they use them, or if there's no target file
2357 name after the redirection symbol. */
2358 if (d
[-1] == '>' || d
[-1] == '<')
2363 if (redir_open (buf
, inp
, out
, err
) == 0)
2368 /* Parse the command line for redirection specs and prepare the file
2369 descriptors for the 3 standard streams accordingly. */
2371 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2372 int *inp
, int *out
, int *err
)
2374 const char *s
= cmd_orig
;
2377 bool retval
= false;
2379 while (isspace (*s
))
2384 if (*s
== '"') /* could also support '..' quoting here */
2388 else if (*s
== quote
)
2391 else if (*s
== '\\')
2393 if (s
[1] == '"') /* escaped quote char */
2398 /* Process a single redirection candidate. */
2399 if (*s
== '<' || *s
== '>'
2400 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2401 || (*s
== '0' && s
[1] == '<'))
2403 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2417 #endif /* !__CYGWIN__ */
2419 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2420 EXEC_FILE is the file to run.
2421 ALLARGS is a string containing the arguments to the program.
2422 ENV is the environment vector to pass. Errors reported with error(). */
2425 windows_create_inferior (struct target_ops
*ops
, const char *exec_file
,
2426 const std::string
&origallargs
, char **in_env
,
2431 cygwin_buf_t real_path
[__PMAX
];
2432 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2433 cygwin_buf_t infcwd
[__PMAX
];
2435 cygwin_buf_t
*toexec
;
2436 cygwin_buf_t
*cygallargs
;
2438 char **old_env
= NULL
;
2442 int ostdin
, ostdout
, ostderr
;
2443 #else /* !__CYGWIN__ */
2444 char real_path
[__PMAX
];
2445 char shell
[__PMAX
]; /* Path to shell */
2447 char *args
, *allargs_copy
;
2448 size_t args_len
, allargs_len
;
2449 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2450 HANDLE tty
= INVALID_HANDLE_VALUE
;
2451 HANDLE inf_stdin
= INVALID_HANDLE_VALUE
;
2452 HANDLE inf_stdout
= INVALID_HANDLE_VALUE
;
2453 HANDLE inf_stderr
= INVALID_HANDLE_VALUE
;
2454 bool redirected
= false;
2461 #endif /* !__CYGWIN__ */
2462 const char *allargs
= origallargs
.c_str ();
2463 PROCESS_INFORMATION pi
;
2466 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2469 error (_("No executable specified, use `target exec'."));
2471 const char *inferior_cwd
= get_inferior_cwd ();
2472 std::string expanded_infcwd
;
2473 if (inferior_cwd
!= NULL
)
2475 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2476 /* Mirror slashes on inferior's cwd. */
2477 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2479 inferior_cwd
= expanded_infcwd
.c_str ();
2482 memset (&si
, 0, sizeof (si
));
2483 si
.cb
= sizeof (si
);
2486 flags
|= CREATE_NEW_PROCESS_GROUP
;
2489 windows_set_console_info (&si
, &flags
);
2494 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2495 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2496 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2497 error (_("Error starting executable: %d"), errno
);
2500 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2501 if (len
== (size_t) -1)
2502 error (_("Error starting executable: %d"), errno
);
2503 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2504 mbstowcs (cygallargs
, allargs
, len
);
2505 #else /* !__USEWIDE */
2506 cygallargs
= allargs
;
2511 sh
= getenv ("SHELL");
2514 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2515 error (_("Error starting executable via shell: %d"), errno
);
2517 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2518 + mbstowcs (NULL
, allargs
, 0) + 2;
2519 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2520 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2521 #else /* !__USEWIDE */
2522 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2523 + strlen (allargs
) + 2);
2524 cygallargs
= (char *) alloca (len
);
2525 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2526 #endif /* __USEWIDE */
2528 flags
|= DEBUG_PROCESS
;
2531 if (inferior_cwd
!= NULL
2532 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2533 infcwd
, strlen (inferior_cwd
)) < 0)
2534 error (_("Error converting inferior cwd: %d"), errno
);
2537 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2538 * sizeof (wchar_t));
2539 wcscpy (args
, toexec
);
2540 wcscat (args
, L
" ");
2541 wcscat (args
, cygallargs
);
2542 #else /* !__USEWIDE */
2543 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2544 strcpy (args
, toexec
);
2546 strcat (args
, cygallargs
);
2547 #endif /* !__USEWIDE */
2549 #ifdef CW_CVT_ENV_TO_WINENV
2550 /* First try to create a direct Win32 copy of the POSIX environment. */
2551 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2552 if (w32_env
!= (PWCHAR
) -1)
2553 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2555 /* If that fails, fall back to old method tweaking GDB's environment. */
2556 #endif /* CW_CVT_ENV_TO_WINENV */
2558 /* Reset all Win32 environment variables to avoid leftover on next run. */
2559 clear_win32_environment (environ
);
2560 /* Prepare the environment vars for CreateProcess. */
2563 cygwin_internal (CW_SYNC_WINENV
);
2567 if (!inferior_io_terminal
)
2568 tty
= ostdin
= ostdout
= ostderr
= -1;
2571 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2574 print_sys_errmsg (inferior_io_terminal
, errno
);
2575 ostdin
= ostdout
= ostderr
= -1;
2588 windows_init_thread_list ();
2589 ret
= CreateProcess (0,
2590 args
, /* command line */
2591 NULL
, /* Security */
2593 TRUE
, /* inherit handles */
2594 flags
, /* start flags */
2595 w32_env
, /* environment */
2596 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2601 /* Just free the Win32 environment, if it could be created. */
2605 /* Reset all environment variables to avoid leftover on next run. */
2606 clear_win32_environment (in_env
);
2607 /* Restore normal GDB environment variables. */
2609 cygwin_internal (CW_SYNC_WINENV
);
2622 #else /* !__CYGWIN__ */
2623 allargs_len
= strlen (allargs
);
2624 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2625 if (strpbrk (allargs_copy
, "<>") != NULL
)
2630 redirect_inferior_handles (allargs
, allargs_copy
,
2631 &fd_inp
, &fd_out
, &fd_err
);
2633 warning (_("Error in redirection: %s."), strerror (errno
));
2636 allargs_len
= strlen (allargs_copy
);
2638 /* If not all the standard streams are redirected by the command
2639 line, use inferior_io_terminal for those which aren't. */
2640 if (inferior_io_terminal
2641 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2643 SECURITY_ATTRIBUTES sa
;
2644 sa
.nLength
= sizeof(sa
);
2645 sa
.lpSecurityDescriptor
= 0;
2646 sa
.bInheritHandle
= TRUE
;
2647 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2648 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2649 if (tty
== INVALID_HANDLE_VALUE
)
2650 warning (_("Warning: Failed to open TTY %s, error %#x."),
2651 inferior_io_terminal
, (unsigned) GetLastError ());
2653 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2656 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2657 else if (tty
!= INVALID_HANDLE_VALUE
)
2660 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2662 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2663 else if (tty
!= INVALID_HANDLE_VALUE
)
2664 si
.hStdOutput
= tty
;
2666 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2668 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2669 else if (tty
!= INVALID_HANDLE_VALUE
)
2672 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2673 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2677 /* Build the command line, a space-separated list of tokens where
2678 the first token is the name of the module to be executed.
2679 To avoid ambiguities introduced by spaces in the module name,
2681 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2682 args
= (char *) alloca (args_len
);
2683 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2685 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2687 /* CreateProcess takes the environment list as a null terminated set of
2688 strings (i.e. two nulls terminate the list). */
2690 /* Get total size for env strings. */
2691 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2692 envlen
+= strlen (in_env
[i
]) + 1;
2694 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2695 env
= (char **) alloca (envsize
);
2696 memcpy (env
, in_env
, envsize
);
2697 /* Windows programs expect the environment block to be sorted. */
2698 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2700 w32env
= (char *) alloca (envlen
+ 1);
2702 /* Copy env strings into new buffer. */
2703 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2705 strcpy (temp
, env
[i
]);
2706 temp
+= strlen (temp
) + 1;
2709 /* Final nil string to terminate new env. */
2712 windows_init_thread_list ();
2713 ret
= CreateProcessA (0,
2714 args
, /* command line */
2715 NULL
, /* Security */
2717 TRUE
, /* inherit handles */
2718 flags
, /* start flags */
2719 w32env
, /* environment */
2720 inferior_cwd
, /* current directory */
2723 if (tty
!= INVALID_HANDLE_VALUE
)
2731 #endif /* !__CYGWIN__ */
2734 error (_("Error creating process %s, (error %u)."),
2735 exec_file
, (unsigned) GetLastError ());
2737 CloseHandle (pi
.hThread
);
2738 CloseHandle (pi
.hProcess
);
2740 if (useshell
&& shell
[0] != '\0')
2745 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2747 /* windows_continue (DBG_CONTINUE, -1, 0); */
2751 windows_mourn_inferior (struct target_ops
*ops
)
2753 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2754 x86_cleanup_dregs();
2755 if (open_process_used
)
2757 CHECK (CloseHandle (current_process_handle
));
2758 open_process_used
= 0;
2760 inf_child_mourn_inferior (ops
);
2763 /* Send a SIGINT to the process group. This acts just like the user typed a
2764 ^C on the controlling terminal. */
2767 windows_interrupt (struct target_ops
*self
, ptid_t ptid
)
2769 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2770 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2771 registers_changed (); /* refresh register state */
2774 /* Helper for windows_xfer_partial that handles memory transfers.
2775 Arguments are like target_xfer_partial. */
2777 static enum target_xfer_status
2778 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2779 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2783 DWORD lasterror
= 0;
2785 if (writebuf
!= NULL
)
2787 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2788 pulongest (len
), core_addr_to_string (memaddr
)));
2789 success
= WriteProcessMemory (current_process_handle
,
2790 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2793 lasterror
= GetLastError ();
2794 FlushInstructionCache (current_process_handle
,
2795 (LPCVOID
) (uintptr_t) memaddr
, len
);
2799 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2800 pulongest (len
), core_addr_to_string (memaddr
)));
2801 success
= ReadProcessMemory (current_process_handle
,
2802 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2805 lasterror
= GetLastError ();
2807 *xfered_len
= (ULONGEST
) done
;
2808 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2809 return TARGET_XFER_OK
;
2811 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2815 windows_kill_inferior (struct target_ops
*ops
)
2817 CHECK (TerminateProcess (current_process_handle
, 0));
2821 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2823 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2825 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2829 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2833 windows_close (struct target_ops
*self
)
2835 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2836 ptid_get_pid (inferior_ptid
)));
2839 /* Convert pid to printable format. */
2841 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2843 static char buf
[80];
2845 if (ptid_get_tid (ptid
) != 0)
2847 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2848 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2852 return normal_pid_to_str (ptid
);
2855 static enum target_xfer_status
2856 windows_xfer_shared_libraries (struct target_ops
*ops
,
2857 enum target_object object
, const char *annex
,
2858 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2859 ULONGEST offset
, ULONGEST len
,
2860 ULONGEST
*xfered_len
)
2862 struct obstack obstack
;
2868 return TARGET_XFER_E_IO
;
2870 obstack_init (&obstack
);
2871 obstack_grow_str (&obstack
, "<library-list>\n");
2872 for (so
= solib_start
.next
; so
; so
= so
->next
)
2874 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2876 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2877 (uintptr_t) li
->load_addr
,
2878 target_gdbarch (), &obstack
);
2880 obstack_grow_str0 (&obstack
, "</library-list>\n");
2882 buf
= (const char *) obstack_finish (&obstack
);
2883 len_avail
= strlen (buf
);
2884 if (offset
>= len_avail
)
2888 if (len
> len_avail
- offset
)
2889 len
= len_avail
- offset
;
2890 memcpy (readbuf
, buf
+ offset
, len
);
2893 obstack_free (&obstack
, NULL
);
2894 *xfered_len
= (ULONGEST
) len
;
2895 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2898 static enum target_xfer_status
2899 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2900 const char *annex
, gdb_byte
*readbuf
,
2901 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2902 ULONGEST
*xfered_len
)
2906 case TARGET_OBJECT_MEMORY
:
2907 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2909 case TARGET_OBJECT_LIBRARIES
:
2910 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2911 writebuf
, offset
, len
, xfered_len
);
2914 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2915 readbuf
, writebuf
, offset
, len
,
2920 /* Provide thread local base, i.e. Thread Information Block address.
2921 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2924 windows_get_tib_address (struct target_ops
*self
,
2925 ptid_t ptid
, CORE_ADDR
*addr
)
2927 windows_thread_info
*th
;
2929 th
= thread_rec (ptid_get_tid (ptid
), 0);
2934 *addr
= th
->thread_local_base
;
2940 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2942 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2945 /* Implementation of the to_thread_name method. */
2948 windows_thread_name (struct target_ops
*self
, struct thread_info
*thr
)
2950 return thread_rec (ptid_get_tid (thr
->ptid
), 0)->name
;
2953 static struct target_ops
*
2954 windows_target (void)
2956 struct target_ops
*t
= inf_child_target ();
2958 t
->to_close
= windows_close
;
2959 t
->to_attach
= windows_attach
;
2960 t
->to_attach_no_wait
= 1;
2961 t
->to_detach
= windows_detach
;
2962 t
->to_resume
= windows_resume
;
2963 t
->to_wait
= windows_wait
;
2964 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2965 t
->to_store_registers
= windows_store_inferior_registers
;
2966 t
->to_xfer_partial
= windows_xfer_partial
;
2967 t
->to_files_info
= windows_files_info
;
2968 t
->to_kill
= windows_kill_inferior
;
2969 t
->to_create_inferior
= windows_create_inferior
;
2970 t
->to_mourn_inferior
= windows_mourn_inferior
;
2971 t
->to_thread_alive
= windows_thread_alive
;
2972 t
->to_pid_to_str
= windows_pid_to_str
;
2973 t
->to_interrupt
= windows_interrupt
;
2974 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2975 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2976 t
->to_get_tib_address
= windows_get_tib_address
;
2977 t
->to_thread_name
= windows_thread_name
;
2983 _initialize_windows_nat (void)
2985 struct target_ops
*t
;
2987 t
= windows_target ();
2989 x86_use_watchpoints (t
);
2991 x86_dr_low
.set_control
= cygwin_set_dr7
;
2992 x86_dr_low
.set_addr
= cygwin_set_dr
;
2993 x86_dr_low
.get_addr
= cygwin_get_dr
;
2994 x86_dr_low
.get_status
= cygwin_get_dr6
;
2995 x86_dr_low
.get_control
= cygwin_get_dr7
;
2997 /* x86_dr_low.debug_register_length field is set by
2998 calling x86_set_debug_register_length function
2999 in processor windows specific native file. */
3004 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3007 add_com ("signal-event", class_run
, signal_event_command
, _("\
3008 Signal a crashed process with event ID, to allow its debugging.\n\
3009 This command is needed in support of setting up GDB as JIT debugger on \
3010 MS-Windows. The command should be invoked from the GDB command line using \
3011 the '-ex' command-line option. The ID of the event that blocks the \
3012 crashed process will be supplied by the Windows JIT debugging mechanism."));
3015 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3016 Set use of shell to start subprocess."), _("\
3017 Show use of shell to start subprocess."), NULL
,
3019 NULL
, /* FIXME: i18n: */
3020 &setlist
, &showlist
);
3022 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3023 &cygwin_exceptions
, _("\
3024 Break when an exception is detected in the Cygwin DLL itself."), _("\
3025 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3027 NULL
, /* FIXME: i18n: */
3028 &setlist
, &showlist
);
3031 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3032 Set creation of new console when creating child process."), _("\
3033 Show creation of new console when creating child process."), NULL
,
3035 NULL
, /* FIXME: i18n: */
3036 &setlist
, &showlist
);
3038 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3039 Set creation of new group when creating child process."), _("\
3040 Show creation of new group when creating child process."), NULL
,
3042 NULL
, /* FIXME: i18n: */
3043 &setlist
, &showlist
);
3045 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3046 Set whether to display execution in child process."), _("\
3047 Show whether to display execution in child process."), NULL
,
3049 NULL
, /* FIXME: i18n: */
3050 &setlist
, &showlist
);
3052 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3053 Set whether to display kernel events in child process."), _("\
3054 Show whether to display kernel events in child process."), NULL
,
3056 NULL
, /* FIXME: i18n: */
3057 &setlist
, &showlist
);
3059 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3060 Set whether to display memory accesses in child process."), _("\
3061 Show whether to display memory accesses in child process."), NULL
,
3063 NULL
, /* FIXME: i18n: */
3064 &setlist
, &showlist
);
3066 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3067 &debug_exceptions
, _("\
3068 Set whether to display kernel exceptions in child process."), _("\
3069 Show whether to display kernel exceptions in child process."), NULL
,
3071 NULL
, /* FIXME: i18n: */
3072 &setlist
, &showlist
);
3074 init_w32_command_list ();
3076 add_cmd ("selector", class_info
, display_selectors
,
3077 _("Display selectors infos."),
3081 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3083 /* Pass the address ADDR to the inferior in the I'th debug register.
3084 Here we just store the address in dr array, the registers will be
3085 actually set up when windows_continue is called. */
3087 cygwin_set_dr (int i
, CORE_ADDR addr
)
3090 internal_error (__FILE__
, __LINE__
,
3091 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3093 debug_registers_changed
= 1;
3094 debug_registers_used
= 1;
3097 /* Pass the value VAL to the inferior in the DR7 debug control
3098 register. Here we just store the address in D_REGS, the watchpoint
3099 will be actually set up in windows_wait. */
3101 cygwin_set_dr7 (unsigned long val
)
3103 dr
[7] = (CORE_ADDR
) val
;
3104 debug_registers_changed
= 1;
3105 debug_registers_used
= 1;
3108 /* Get the value of debug register I from the inferior. */
3111 cygwin_get_dr (int i
)
3116 /* Get the value of the DR6 debug status register from the inferior.
3117 Here we just return the value stored in dr[6]
3118 by the last call to thread_rec for current_event.dwThreadId id. */
3119 static unsigned long
3120 cygwin_get_dr6 (void)
3122 return (unsigned long) dr
[6];
3125 /* Get the value of the DR7 debug status register from the inferior.
3126 Here we just return the value stored in dr[7] by the last call to
3127 thread_rec for current_event.dwThreadId id. */
3129 static unsigned long
3130 cygwin_get_dr7 (void)
3132 return (unsigned long) dr
[7];
3135 /* Determine if the thread referenced by "ptid" is alive
3136 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3137 it means that the thread has died. Otherwise it is assumed to be alive. */
3139 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
3143 gdb_assert (ptid_get_tid (ptid
) != 0);
3144 tid
= ptid_get_tid (ptid
);
3146 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
3151 _initialize_check_for_gdb_ini (void)
3154 if (inhibit_gdbinit
)
3157 homedir
= getenv ("HOME");
3161 char *oldini
= (char *) alloca (strlen (homedir
) +
3162 sizeof ("gdb.ini") + 1);
3163 strcpy (oldini
, homedir
);
3164 p
= strchr (oldini
, '\0');
3165 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3167 strcpy (p
, "gdb.ini");
3168 if (access (oldini
, 0) == 0)
3170 int len
= strlen (oldini
);
3171 char *newini
= (char *) alloca (len
+ 2);
3173 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3174 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3175 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3180 /* Define dummy functions which always return error for the rare cases where
3181 these functions could not be found. */
3183 bad_DebugActiveProcessStop (DWORD w
)
3188 bad_DebugBreakProcess (HANDLE w
)
3193 bad_DebugSetProcessKillOnExit (BOOL w
)
3198 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3205 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3211 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3218 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3224 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3230 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3236 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3244 /* Load any functions which may not be available in ancient versions
3248 _initialize_loadable (void)
3252 #define GPA(m, func) \
3253 func = (func ## _ftype *) GetProcAddress (m, #func)
3255 hm
= LoadLibrary ("kernel32.dll");
3258 GPA (hm
, DebugActiveProcessStop
);
3259 GPA (hm
, DebugBreakProcess
);
3260 GPA (hm
, DebugSetProcessKillOnExit
);
3261 GPA (hm
, GetConsoleFontSize
);
3262 GPA (hm
, DebugActiveProcessStop
);
3263 GPA (hm
, GetCurrentConsoleFont
);
3266 /* Set variables to dummy versions of these processes if the function
3267 wasn't found in kernel32.dll. */
3268 if (!DebugBreakProcess
)
3269 DebugBreakProcess
= bad_DebugBreakProcess
;
3270 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3272 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3273 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3275 if (!GetConsoleFontSize
)
3276 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3277 if (!GetCurrentConsoleFont
)
3278 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3280 /* Load optional functions used for retrieving filename information
3281 associated with the currently debugged process or its dlls. */
3282 hm
= LoadLibrary ("psapi.dll");
3285 GPA (hm
, EnumProcessModules
);
3286 GPA (hm
, GetModuleInformation
);
3287 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3288 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3291 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3293 /* Set variables to dummy versions of these processes if the function
3294 wasn't found in psapi.dll. */
3295 EnumProcessModules
= bad_EnumProcessModules
;
3296 GetModuleInformation
= bad_GetModuleInformation
;
3297 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3298 /* This will probably fail on Windows 9x/Me. Let the user know
3299 that we're missing some functionality. */
3301 cannot automatically find executable file or library to read symbols.\n\
3302 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3305 hm
= LoadLibrary ("advapi32.dll");
3308 GPA (hm
, OpenProcessToken
);
3309 GPA (hm
, LookupPrivilegeValueA
);
3310 GPA (hm
, AdjustTokenPrivileges
);
3311 /* Only need to set one of these since if OpenProcessToken fails nothing
3313 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3314 || !AdjustTokenPrivileges
)
3315 OpenProcessToken
= bad_OpenProcessToken
;