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>
47 #include "buildsym-legacy.h"
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "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 cygwin_set_dr (int i
, CORE_ADDR addr
);
205 static void cygwin_set_dr7 (unsigned long val
);
206 static CORE_ADDR
cygwin_get_dr (int i
);
207 static unsigned long cygwin_get_dr6 (void);
208 static unsigned long cygwin_get_dr7 (void);
210 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
211 /* Set if a signal was received from the debugged process. */
213 /* Thread information structure used to track information that is
214 not available in gdb's thread structure. */
215 typedef struct windows_thread_info_struct
217 struct windows_thread_info_struct
*next
;
220 CORE_ADDR thread_local_base
;
229 static windows_thread_info thread_head
;
231 /* The process and thread handles for the above context. */
233 static DEBUG_EVENT current_event
; /* The current debug event from
235 static HANDLE current_process_handle
; /* Currently executing process */
236 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
237 static DWORD main_thread_id
; /* Thread ID of the main thread */
239 /* Counts of things. */
240 static int exception_count
= 0;
241 static int event_count
= 0;
242 static int saw_create
;
243 static int open_process_used
= 0;
246 static int new_console
= 0;
248 static int cygwin_exceptions
= 0;
250 static int new_group
= 1;
251 static int debug_exec
= 0; /* show execution */
252 static int debug_events
= 0; /* show events from kernel */
253 static int debug_memory
= 0; /* show target memory accesses */
254 static int debug_exceptions
= 0; /* show target exceptions */
255 static int useshell
= 0; /* use shell for subprocesses */
257 /* This vector maps GDB's idea of a register's number into an offset
258 in the windows exception context vector.
260 It also contains the bit mask needed to load the register in question.
262 The contents of this table can only be computed by the units
263 that provide CPU-specific support for Windows native debugging.
264 These units should set the table by calling
265 windows_set_context_register_offsets.
267 One day we could read a reg, we could inspect the context we
268 already have loaded, if it doesn't have the bit set that we need,
269 we read that set of registers in using GetThreadContext. If the
270 context already contains what we need, we just unpack it. Then to
271 write a register, first we have to ensure that the context contains
272 the other regs of the group, and then we copy the info in and set
275 static const int *mappings
;
277 /* The function to use in order to determine whether a register is
278 a segment register or not. */
279 static segment_register_p_ftype
*segment_register_p
;
281 /* This vector maps the target's idea of an exception (extracted
282 from the DEBUG_EVENT structure) to GDB's idea. */
284 struct xlate_exception
290 static const struct xlate_exception
293 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
294 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
295 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
296 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
297 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
298 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
299 {-1, GDB_SIGNAL_UNKNOWN
}};
302 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
304 void close () override
;
306 void attach (const char *, int) override
;
308 bool attach_no_wait () override
311 void detach (inferior
*, int) override
;
313 void resume (ptid_t
, int , enum gdb_signal
) override
;
315 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
317 void fetch_registers (struct regcache
*, int) override
;
318 void store_registers (struct regcache
*, int) override
;
320 enum target_xfer_status
xfer_partial (enum target_object object
,
323 const gdb_byte
*writebuf
,
324 ULONGEST offset
, ULONGEST len
,
325 ULONGEST
*xfered_len
) override
;
327 void files_info () override
;
329 void kill () override
;
331 void create_inferior (const char *, const std::string
&,
332 char **, int) override
;
334 void mourn_inferior () override
;
336 bool thread_alive (ptid_t ptid
) override
;
338 const char *pid_to_str (ptid_t
) override
;
340 void interrupt () override
;
342 char *pid_to_exec_file (int pid
) override
;
344 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
346 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
348 const char *thread_name (struct thread_info
*) override
;
351 static windows_nat_target the_windows_nat_target
;
353 /* Set the MAPPINGS static global to OFFSETS.
354 See the description of MAPPINGS for more details. */
357 windows_set_context_register_offsets (const int *offsets
)
362 /* See windows-nat.h. */
365 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
367 segment_register_p
= fun
;
371 check (BOOL ok
, const char *file
, int line
)
374 printf_filtered ("error return %s:%d was %u\n", file
, line
,
375 (unsigned) GetLastError ());
378 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
379 then also retrieve the context for this thread. If GET_CONTEXT is
380 negative, then don't suspend the thread. */
381 static windows_thread_info
*
382 thread_rec (DWORD id
, int get_context
)
384 windows_thread_info
*th
;
386 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
389 if (!th
->suspended
&& get_context
)
391 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
393 if (SuspendThread (th
->h
) == (DWORD
) -1)
395 DWORD err
= GetLastError ();
397 /* We get Access Denied (5) when trying to suspend
398 threads that Windows started on behalf of the
399 debuggee, usually when those threads are just
401 We can get Invalid Handle (6) if the main thread
403 if (err
!= ERROR_INVALID_HANDLE
404 && err
!= ERROR_ACCESS_DENIED
)
405 warning (_("SuspendThread (tid=0x%x) failed."
407 (unsigned) id
, (unsigned) err
);
413 else if (get_context
< 0)
415 th
->reload_context
= 1;
423 /* Add a thread to the thread list. */
424 static windows_thread_info
*
425 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
427 windows_thread_info
*th
;
430 gdb_assert (ptid
.tid () != 0);
434 if ((th
= thread_rec (id
, FALSE
)))
437 th
= XCNEW (windows_thread_info
);
440 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
441 th
->next
= thread_head
.next
;
442 thread_head
.next
= th
;
444 /* Set the debug registers for the new thread if they are used. */
445 if (debug_registers_used
)
447 /* Only change the value of the debug registers. */
448 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
449 CHECK (GetThreadContext (th
->h
, &th
->context
));
450 th
->context
.Dr0
= dr
[0];
451 th
->context
.Dr1
= dr
[1];
452 th
->context
.Dr2
= dr
[2];
453 th
->context
.Dr3
= dr
[3];
454 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
455 th
->context
.Dr7
= dr
[7];
456 CHECK (SetThreadContext (th
->h
, &th
->context
));
457 th
->context
.ContextFlags
= 0;
462 /* Clear out any old thread list and reinitialize it to a
465 windows_init_thread_list (void)
467 windows_thread_info
*th
= &thread_head
;
469 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
471 while (th
->next
!= NULL
)
473 windows_thread_info
*here
= th
->next
;
474 th
->next
= here
->next
;
477 thread_head
.next
= NULL
;
480 /* Delete a thread from the list of threads. */
482 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
484 windows_thread_info
*th
;
487 gdb_assert (ptid
.tid () != 0);
492 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
493 else if (print_thread_events
&& id
!= main_thread_id
)
494 printf_unfiltered (_("[%s exited with code %u]\n"),
495 target_pid_to_str (ptid
), (unsigned) exit_code
);
496 delete_thread (find_thread_ptid (ptid
));
498 for (th
= &thread_head
;
499 th
->next
!= NULL
&& th
->next
->id
!= id
;
503 if (th
->next
!= NULL
)
505 windows_thread_info
*here
= th
->next
;
506 th
->next
= here
->next
;
512 /* Fetches register number R from the given windows_thread_info,
513 and supplies its value to the given regcache.
515 This function assumes that R is non-negative. A failed assertion
516 is raised if that is not true.
518 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
519 that the windows_thread_info has an up-to-date context. A failed
520 assertion is raised if that assumption is violated. */
523 windows_fetch_one_register (struct regcache
*regcache
,
524 windows_thread_info
*th
, int r
)
527 gdb_assert (!th
->reload_context
);
529 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
530 struct gdbarch
*gdbarch
= regcache
->arch ();
531 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
533 if (r
== I387_FISEG_REGNUM (tdep
))
535 long l
= *((long *) context_offset
) & 0xffff;
536 regcache
->raw_supply (r
, (char *) &l
);
538 else if (r
== I387_FOP_REGNUM (tdep
))
540 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
541 regcache
->raw_supply (r
, (char *) &l
);
543 else if (segment_register_p (r
))
545 /* GDB treats segment registers as 32bit registers, but they are
546 in fact only 16 bits long. Make sure we do not read extra
547 bits from our source buffer. */
548 long l
= *((long *) context_offset
) & 0xffff;
549 regcache
->raw_supply (r
, (char *) &l
);
552 regcache
->raw_supply (r
, context_offset
);
556 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
558 DWORD pid
= regcache
->ptid ().tid ();
559 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
561 /* Check if TH exists. Windows sometimes uses a non-existent
562 thread id in its events. */
566 if (th
->reload_context
)
569 if (have_saved_context
)
571 /* Lie about where the program actually is stopped since
572 cygwin has informed us that we should consider the signal
573 to have occurred at another location which is stored in
575 memcpy (&th
->context
, &saved_context
,
576 __COPY_CONTEXT_SIZE
);
577 have_saved_context
= 0;
582 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
583 CHECK (GetThreadContext (th
->h
, &th
->context
));
584 /* Copy dr values from that thread.
585 But only if there were not modified since last stop.
587 if (!debug_registers_changed
)
589 dr
[0] = th
->context
.Dr0
;
590 dr
[1] = th
->context
.Dr1
;
591 dr
[2] = th
->context
.Dr2
;
592 dr
[3] = th
->context
.Dr3
;
593 dr
[6] = th
->context
.Dr6
;
594 dr
[7] = th
->context
.Dr7
;
597 th
->reload_context
= 0;
601 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
602 windows_fetch_one_register (regcache
, th
, r
);
604 windows_fetch_one_register (regcache
, th
, r
);
607 /* Collect the register number R from the given regcache, and store
608 its value into the corresponding area of the given thread's context.
610 This function assumes that R is non-negative. A failed assertion
611 assertion is raised if that is not true. */
614 windows_store_one_register (const struct regcache
*regcache
,
615 windows_thread_info
*th
, int r
)
619 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
622 /* Store a new register value into the context of the thread tied to
626 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
628 DWORD pid
= regcache
->ptid ().tid ();
629 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
631 /* Check if TH exists. Windows sometimes uses a non-existent
632 thread id in its events. */
637 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
638 windows_store_one_register (regcache
, th
, r
);
640 windows_store_one_register (regcache
, th
, r
);
643 /* Encapsulate the information required in a call to
644 symbol_file_add_args. */
645 struct safe_symbol_file_add_args
649 section_addr_info
*addrs
;
652 struct ui_file
*err
, *out
;
656 /* Maintain a linked list of "so" information. */
657 struct lm_info_windows
: public lm_info_base
659 LPVOID load_addr
= 0;
662 static struct so_list solib_start
, *solib_end
;
664 static struct so_list
*
665 windows_make_so (const char *name
, LPVOID load_addr
)
672 WIN32_FIND_DATA w32_fd
;
673 HANDLE h
= FindFirstFile(name
, &w32_fd
);
675 if (h
== INVALID_HANDLE_VALUE
)
681 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
683 p
= strrchr (buf
, '\\');
686 SetCurrentDirectory (buf
);
687 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
688 SetCurrentDirectory (cwd
);
691 if (strcasecmp (buf
, "ntdll.dll") == 0)
693 GetSystemDirectory (buf
, sizeof (buf
));
694 strcat (buf
, "\\ntdll.dll");
697 cygwin_buf_t buf
[__PMAX
];
700 if (access (name
, F_OK
) != 0)
702 if (strcasecmp (name
, "ntdll.dll") == 0)
705 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
706 wcscat (buf
, L
"\\ntdll.dll");
710 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
711 strcat (buf
, "\\ntdll.dll");
716 so
= XCNEW (struct so_list
);
717 lm_info_windows
*li
= new lm_info_windows
;
719 li
->load_addr
= load_addr
;
720 strcpy (so
->so_original_name
, name
);
722 strcpy (so
->so_name
, buf
);
725 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
726 SO_NAME_MAX_PATH_SIZE
);
729 char *rname
= realpath (name
, NULL
);
730 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
732 strcpy (so
->so_name
, rname
);
736 error (_("dll path too long"));
738 /* Record cygwin1.dll .text start/end. */
739 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
740 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
742 asection
*text
= NULL
;
745 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
750 if (bfd_check_format (abfd
.get (), bfd_object
))
751 text
= bfd_get_section_by_name (abfd
.get (), ".text");
756 /* The symbols in a dll are offset by 0x1000, which is the
757 offset from 0 of the first byte in an image - because of the
758 file header and the section alignment. */
759 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
761 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
770 get_image_name (HANDLE h
, void *address
, int unicode
)
773 static char buf
[__PMAX
];
775 static char buf
[(2 * __PMAX
) + 1];
777 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
783 /* Attempt to read the name of the dll that was detected.
784 This is documented to work only when actively debugging
785 a program. It will not work for attached processes. */
789 /* See if we could read the address of a string, and that the
790 address isn't null. */
791 if (!ReadProcessMemory (h
, address
, &address_ptr
,
792 sizeof (address_ptr
), &done
)
793 || done
!= sizeof (address_ptr
) || !address_ptr
)
796 /* Find the length of the string. */
797 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
798 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
802 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
805 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
806 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
809 wcstombs (buf
, unicode_address
, __PMAX
);
811 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
819 /* Handle a DLL load event, and return 1.
821 This function assumes that this event did not occur during inferior
822 initialization, where their event info may be incomplete (see
823 do_initial_windows_stuff and windows_add_all_dlls for more info
824 on how we handle DLL loading during that phase). */
829 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
832 /* Try getting the DLL name via the lpImageName field of the event.
833 Note that Microsoft documents this fields as strictly optional,
834 in the sense that it might be NULL. And the first DLL event in
835 particular is explicitly documented as "likely not pass[ed]"
836 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
837 dll_name
= get_image_name (current_process_handle
,
838 event
->lpImageName
, event
->fUnicode
);
842 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
843 solib_end
= solib_end
->next
;
845 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
847 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
848 host_address_to_string (li
->load_addr
)));
852 windows_free_so (struct so_list
*so
)
854 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
860 /* Handle a DLL unload event.
861 Return 1 if successful, or zero otherwise.
863 This function assumes that this event did not occur during inferior
864 initialization, where their event info may be incomplete (see
865 do_initial_windows_stuff and windows_add_all_dlls for more info
866 on how we handle DLL loading during that phase). */
871 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
874 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
876 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
878 if (li_next
->load_addr
== lpBaseOfDll
)
880 struct so_list
*sodel
= so
->next
;
882 so
->next
= sodel
->next
;
885 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
887 windows_free_so (sodel
);
892 /* We did not find any DLL that was previously loaded at this address,
893 so register a complaint. We do not report an error, because we have
894 observed that this may be happening under some circumstances. For
895 instance, running 32bit applications on x64 Windows causes us to receive
896 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
897 events are apparently caused by the WOW layer, the interface between
898 32bit and 64bit worlds). */
899 complaint (_("dll starting at %s not found."),
900 host_address_to_string (lpBaseOfDll
));
903 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
907 catch_errors (void (*func
) ())
913 CATCH (ex
, RETURN_MASK_ALL
)
915 exception_print (gdb_stderr
, ex
);
920 /* Clear list of loaded DLLs. */
922 windows_clear_solib (void)
924 solib_start
.next
= NULL
;
925 solib_end
= &solib_start
;
929 signal_event_command (const char *args
, int from_tty
)
931 uintptr_t event_id
= 0;
932 char *endargs
= NULL
;
935 error (_("signal-event requires an argument (integer event id)"));
937 event_id
= strtoumax (args
, &endargs
, 10);
939 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
940 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
941 error (_("Failed to convert `%s' to event id"), args
);
943 SetEvent ((HANDLE
) event_id
);
944 CloseHandle ((HANDLE
) event_id
);
947 /* Handle DEBUG_STRING output from child process.
948 Cygwin prepends its messages with a "cygwin:". Interpret this as
949 a Cygwin signal. Otherwise just print the string as a warning. */
951 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
953 gdb::unique_xmalloc_ptr
<char> s
;
956 if (!target_read_string
957 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
959 || !s
|| !*(s
.get ()))
961 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
964 if (!startswith (s
.get (), "cYg"))
967 char *p
= strchr (s
.get (), '\0');
969 if (p
> s
.get () && *--p
== '\n')
971 warning (("%s"), s
.get ());
977 /* Got a cygwin signal marker. A cygwin signal is followed by
978 the signal number itself and then optionally followed by the
979 thread id and address to saved context within the DLL. If
980 these are supplied, then the given thread is assumed to have
981 issued the signal and the context from the thread is assumed
982 to be stored at the given address in the inferior. Tell gdb
983 to treat this like a real signal. */
985 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
986 gdb_signal gotasig
= gdb_signal_from_host (sig
);
988 ourstatus
->value
.sig
= gotasig
;
994 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
995 retval
= strtoul (p
, &p
, 0);
997 retval
= main_thread_id
;
998 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
999 && ReadProcessMemory (current_process_handle
, x
,
1001 __COPY_CONTEXT_SIZE
, &n
)
1002 && n
== __COPY_CONTEXT_SIZE
)
1003 have_saved_context
= 1;
1012 display_selector (HANDLE thread
, DWORD sel
)
1015 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1018 printf_filtered ("0x%03x: ", (unsigned) sel
);
1019 if (!info
.HighWord
.Bits
.Pres
)
1021 puts_filtered ("Segment not present\n");
1024 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1025 (info
.HighWord
.Bits
.BaseMid
<< 16)
1027 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1028 if (info
.HighWord
.Bits
.Granularity
)
1029 limit
= (limit
<< 12) | 0xfff;
1030 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1031 if (info
.HighWord
.Bits
.Default_Big
)
1032 puts_filtered(" 32-bit ");
1034 puts_filtered(" 16-bit ");
1035 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1038 puts_filtered ("Data (Read-Only, Exp-up");
1041 puts_filtered ("Data (Read/Write, Exp-up");
1044 puts_filtered ("Unused segment (");
1047 puts_filtered ("Data (Read/Write, Exp-down");
1050 puts_filtered ("Code (Exec-Only, N.Conf");
1053 puts_filtered ("Code (Exec/Read, N.Conf");
1056 puts_filtered ("Code (Exec-Only, Conf");
1059 puts_filtered ("Code (Exec/Read, Conf");
1062 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1064 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1065 puts_filtered(", N.Acc");
1066 puts_filtered (")\n");
1067 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1068 puts_filtered("System selector ");
1069 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1070 if (info
.HighWord
.Bits
.Granularity
)
1071 puts_filtered ("Page granular.\n");
1073 puts_filtered ("Byte granular.\n");
1078 DWORD err
= GetLastError ();
1079 if (err
== ERROR_NOT_SUPPORTED
)
1080 printf_filtered ("Function not supported\n");
1082 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1088 display_selectors (const char * args
, int from_tty
)
1090 if (!current_thread
)
1092 puts_filtered ("Impossible to display selectors now.\n");
1098 puts_filtered ("Selector $cs\n");
1099 display_selector (current_thread
->h
,
1100 current_thread
->context
.SegCs
);
1101 puts_filtered ("Selector $ds\n");
1102 display_selector (current_thread
->h
,
1103 current_thread
->context
.SegDs
);
1104 puts_filtered ("Selector $es\n");
1105 display_selector (current_thread
->h
,
1106 current_thread
->context
.SegEs
);
1107 puts_filtered ("Selector $ss\n");
1108 display_selector (current_thread
->h
,
1109 current_thread
->context
.SegSs
);
1110 puts_filtered ("Selector $fs\n");
1111 display_selector (current_thread
->h
,
1112 current_thread
->context
.SegFs
);
1113 puts_filtered ("Selector $gs\n");
1114 display_selector (current_thread
->h
,
1115 current_thread
->context
.SegGs
);
1120 sel
= parse_and_eval_long (args
);
1121 printf_filtered ("Selector \"%s\"\n",args
);
1122 display_selector (current_thread
->h
, sel
);
1126 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1127 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1128 host_address_to_string (\
1129 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1131 static handle_exception_result
1132 handle_exception (struct target_waitstatus
*ourstatus
)
1134 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1135 DWORD code
= rec
->ExceptionCode
;
1136 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1138 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1140 /* Record the context of the current thread. */
1141 thread_rec (current_event
.dwThreadId
, -1);
1145 case EXCEPTION_ACCESS_VIOLATION
:
1146 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1147 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1150 /* See if the access violation happened within the cygwin DLL
1151 itself. Cygwin uses a kind of exception handling to deal
1152 with passed-in invalid addresses. gdb should not treat
1153 these as real SEGVs since they will be silently handled by
1154 cygwin. A real SEGV will (theoretically) be caught by
1155 cygwin later in the process and will be sent as a
1156 cygwin-specific-signal. So, ignore SEGVs if they show up
1157 within the text segment of the DLL itself. */
1159 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1161 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1162 && addr
< cygwin_load_end
))
1163 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1164 && startswith (fn
, "KERNEL32!IsBad")))
1165 return HANDLE_EXCEPTION_UNHANDLED
;
1169 case STATUS_STACK_OVERFLOW
:
1170 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1171 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1173 case STATUS_FLOAT_DENORMAL_OPERAND
:
1174 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1175 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1177 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1178 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1179 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1181 case STATUS_FLOAT_INEXACT_RESULT
:
1182 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1183 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1185 case STATUS_FLOAT_INVALID_OPERATION
:
1186 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1187 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1189 case STATUS_FLOAT_OVERFLOW
:
1190 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1191 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1193 case STATUS_FLOAT_STACK_CHECK
:
1194 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1195 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1197 case STATUS_FLOAT_UNDERFLOW
:
1198 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1199 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1201 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1202 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1203 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1205 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1206 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1209 case STATUS_INTEGER_OVERFLOW
:
1210 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1213 case EXCEPTION_BREAKPOINT
:
1214 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1218 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1221 case DBG_CONTROL_BREAK
:
1222 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1223 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1225 case EXCEPTION_SINGLE_STEP
:
1226 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1227 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1229 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1230 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1231 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1233 case EXCEPTION_PRIV_INSTRUCTION
:
1234 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1235 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1237 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1238 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1239 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1241 case MS_VC_EXCEPTION
:
1242 if (rec
->NumberParameters
>= 3
1243 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1245 DWORD named_thread_id
;
1246 windows_thread_info
*named_thread
;
1247 CORE_ADDR thread_name_target
;
1249 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1251 thread_name_target
= rec
->ExceptionInformation
[1];
1252 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1254 if (named_thread_id
== (DWORD
) -1)
1255 named_thread_id
= current_event
.dwThreadId
;
1257 named_thread
= thread_rec (named_thread_id
, 0);
1258 if (named_thread
!= NULL
)
1260 int thread_name_len
;
1261 gdb::unique_xmalloc_ptr
<char> thread_name
;
1263 thread_name_len
= target_read_string (thread_name_target
,
1264 &thread_name
, 1025, NULL
);
1265 if (thread_name_len
> 0)
1267 thread_name
.get ()[thread_name_len
- 1] = '\0';
1268 xfree (named_thread
->name
);
1269 named_thread
->name
= thread_name
.release ();
1272 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1273 result
= HANDLE_EXCEPTION_IGNORED
;
1276 /* treat improperly formed exception as unknown */
1279 /* Treat unhandled first chance exceptions specially. */
1280 if (current_event
.u
.Exception
.dwFirstChance
)
1281 return HANDLE_EXCEPTION_UNHANDLED
;
1282 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1283 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1284 host_address_to_string (
1285 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1286 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1290 last_sig
= ourstatus
->value
.sig
;
1294 /* Resume thread specified by ID, or all artificially suspended
1295 threads, if we are continuing execution. KILLED non-zero means we
1296 have killed the inferior, so we should ignore weird errors due to
1297 threads shutting down. */
1299 windows_continue (DWORD continue_status
, int id
, int killed
)
1301 windows_thread_info
*th
;
1304 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1305 (unsigned) current_event
.dwProcessId
,
1306 (unsigned) current_event
.dwThreadId
,
1307 continue_status
== DBG_CONTINUE
?
1308 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1310 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1311 if ((id
== -1 || id
== (int) th
->id
)
1314 if (debug_registers_changed
)
1316 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1317 th
->context
.Dr0
= dr
[0];
1318 th
->context
.Dr1
= dr
[1];
1319 th
->context
.Dr2
= dr
[2];
1320 th
->context
.Dr3
= dr
[3];
1321 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1322 th
->context
.Dr7
= dr
[7];
1324 if (th
->context
.ContextFlags
)
1328 if (GetExitCodeThread (th
->h
, &ec
)
1329 && ec
== STILL_ACTIVE
)
1331 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1336 th
->context
.ContextFlags
= 0;
1338 if (th
->suspended
> 0)
1339 (void) ResumeThread (th
->h
);
1343 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1344 current_event
.dwThreadId
,
1348 error (_("Failed to resume program execution"
1349 " (ContinueDebugEvent failed, error %u)"),
1350 (unsigned int) GetLastError ());
1352 debug_registers_changed
= 0;
1356 /* Called in pathological case where Windows fails to send a
1357 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1359 fake_create_process (void)
1361 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1362 current_event
.dwProcessId
);
1363 if (current_process_handle
!= NULL
)
1364 open_process_used
= 1;
1367 error (_("OpenProcess call failed, GetLastError = %u"),
1368 (unsigned) GetLastError ());
1369 /* We can not debug anything in that case. */
1371 main_thread_id
= current_event
.dwThreadId
;
1372 current_thread
= windows_add_thread (
1373 ptid_t (current_event
.dwProcessId
, 0,
1374 current_event
.dwThreadId
),
1375 current_event
.u
.CreateThread
.hThread
,
1376 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1377 return main_thread_id
;
1381 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1383 windows_thread_info
*th
;
1384 DWORD continue_status
= DBG_CONTINUE
;
1386 /* A specific PTID means `step only this thread id'. */
1387 int resume_all
= ptid
== minus_one_ptid
;
1389 /* If we're continuing all threads, it's the current inferior that
1390 should be handled specially. */
1392 ptid
= inferior_ptid
;
1394 if (sig
!= GDB_SIGNAL_0
)
1396 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1398 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1400 else if (sig
== last_sig
)
1401 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1404 /* This code does not seem to work, because
1405 the kernel does probably not consider changes in the ExceptionRecord
1406 structure when passing the exception to the inferior.
1407 Note that this seems possible in the exception handler itself. */
1410 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1411 if (xlate
[i
].us
== sig
)
1413 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1415 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1418 if (continue_status
== DBG_CONTINUE
)
1420 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1424 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1428 last_sig
= GDB_SIGNAL_0
;
1430 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1431 ptid
.pid (), ptid
.tid (), step
, sig
));
1433 /* Get context for currently selected thread. */
1434 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1439 /* Single step by setting t bit. */
1440 struct regcache
*regcache
= get_current_regcache ();
1441 struct gdbarch
*gdbarch
= regcache
->arch ();
1442 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1443 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1446 if (th
->context
.ContextFlags
)
1448 if (debug_registers_changed
)
1450 th
->context
.Dr0
= dr
[0];
1451 th
->context
.Dr1
= dr
[1];
1452 th
->context
.Dr2
= dr
[2];
1453 th
->context
.Dr3
= dr
[3];
1454 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1455 th
->context
.Dr7
= dr
[7];
1457 CHECK (SetThreadContext (th
->h
, &th
->context
));
1458 th
->context
.ContextFlags
= 0;
1462 /* Allow continuing with the same signal that interrupted us.
1463 Otherwise complain. */
1466 windows_continue (continue_status
, -1, 0);
1468 windows_continue (continue_status
, ptid
.tid (), 0);
1471 /* Ctrl-C handler used when the inferior is not run in the same console. The
1472 handler is in charge of interrupting the inferior using DebugBreakProcess.
1473 Note that this function is not available prior to Windows XP. In this case
1474 we emit a warning. */
1476 ctrl_c_handler (DWORD event_type
)
1478 const int attach_flag
= current_inferior ()->attach_flag
;
1480 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1481 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1484 /* If the inferior and the debugger share the same console, do nothing as
1485 the inferior has also received the Ctrl-C event. */
1486 if (!new_console
&& !attach_flag
)
1489 if (!DebugBreakProcess (current_process_handle
))
1490 warning (_("Could not interrupt program. "
1491 "Press Ctrl-c in the program console."));
1493 /* Return true to tell that Ctrl-C has been handled. */
1497 /* Get the next event from the child. Returns a non-zero thread id if the event
1498 requires handling by WFI (or whatever). */
1500 get_windows_debug_event (struct target_ops
*ops
,
1501 int pid
, struct target_waitstatus
*ourstatus
)
1504 DWORD continue_status
, event_code
;
1505 windows_thread_info
*th
;
1506 static windows_thread_info dummy_thread_info
;
1507 DWORD thread_id
= 0;
1509 last_sig
= GDB_SIGNAL_0
;
1511 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1515 continue_status
= DBG_CONTINUE
;
1517 event_code
= current_event
.dwDebugEventCode
;
1518 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1520 have_saved_context
= 0;
1524 case CREATE_THREAD_DEBUG_EVENT
:
1525 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1526 (unsigned) current_event
.dwProcessId
,
1527 (unsigned) current_event
.dwThreadId
,
1528 "CREATE_THREAD_DEBUG_EVENT"));
1529 if (saw_create
!= 1)
1531 struct inferior
*inf
;
1532 inf
= find_inferior_pid (current_event
.dwProcessId
);
1533 if (!saw_create
&& inf
->attach_flag
)
1535 /* Kludge around a Windows bug where first event is a create
1536 thread event. Caused when attached process does not have
1538 thread_id
= fake_create_process ();
1544 /* Record the existence of this thread. */
1545 thread_id
= current_event
.dwThreadId
;
1546 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1547 current_event
.dwThreadId
),
1548 current_event
.u
.CreateThread
.hThread
,
1549 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1553 case EXIT_THREAD_DEBUG_EVENT
:
1554 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1555 (unsigned) current_event
.dwProcessId
,
1556 (unsigned) current_event
.dwThreadId
,
1557 "EXIT_THREAD_DEBUG_EVENT"));
1559 if (current_event
.dwThreadId
!= main_thread_id
)
1561 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1562 current_event
.dwThreadId
),
1563 current_event
.u
.ExitThread
.dwExitCode
);
1564 th
= &dummy_thread_info
;
1568 case CREATE_PROCESS_DEBUG_EVENT
:
1569 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1570 (unsigned) current_event
.dwProcessId
,
1571 (unsigned) current_event
.dwThreadId
,
1572 "CREATE_PROCESS_DEBUG_EVENT"));
1573 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1574 if (++saw_create
!= 1)
1577 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1579 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1582 main_thread_id
= current_event
.dwThreadId
;
1583 /* Add the main thread. */
1584 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1585 current_event
.dwThreadId
),
1586 current_event
.u
.CreateProcessInfo
.hThread
,
1587 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1588 thread_id
= current_event
.dwThreadId
;
1591 case EXIT_PROCESS_DEBUG_EVENT
:
1592 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1593 (unsigned) current_event
.dwProcessId
,
1594 (unsigned) current_event
.dwThreadId
,
1595 "EXIT_PROCESS_DEBUG_EVENT"));
1596 if (!windows_initialization_done
)
1598 target_terminal::ours ();
1599 target_mourn_inferior (inferior_ptid
);
1600 error (_("During startup program exited with code 0x%x."),
1601 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1603 else if (saw_create
== 1)
1605 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1606 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1607 thread_id
= main_thread_id
;
1611 case LOAD_DLL_DEBUG_EVENT
:
1612 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1613 (unsigned) current_event
.dwProcessId
,
1614 (unsigned) current_event
.dwThreadId
,
1615 "LOAD_DLL_DEBUG_EVENT"));
1616 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1617 if (saw_create
!= 1 || ! windows_initialization_done
)
1619 catch_errors (handle_load_dll
);
1620 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1621 ourstatus
->value
.integer
= 0;
1622 thread_id
= main_thread_id
;
1625 case UNLOAD_DLL_DEBUG_EVENT
:
1626 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1627 (unsigned) current_event
.dwProcessId
,
1628 (unsigned) current_event
.dwThreadId
,
1629 "UNLOAD_DLL_DEBUG_EVENT"));
1630 if (saw_create
!= 1 || ! windows_initialization_done
)
1632 catch_errors (handle_unload_dll
);
1633 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1634 ourstatus
->value
.integer
= 0;
1635 thread_id
= main_thread_id
;
1638 case EXCEPTION_DEBUG_EVENT
:
1639 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1640 (unsigned) current_event
.dwProcessId
,
1641 (unsigned) current_event
.dwThreadId
,
1642 "EXCEPTION_DEBUG_EVENT"));
1643 if (saw_create
!= 1)
1645 switch (handle_exception (ourstatus
))
1647 case HANDLE_EXCEPTION_UNHANDLED
:
1649 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1651 case HANDLE_EXCEPTION_HANDLED
:
1652 thread_id
= current_event
.dwThreadId
;
1654 case HANDLE_EXCEPTION_IGNORED
:
1655 continue_status
= DBG_CONTINUE
;
1660 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1661 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1662 (unsigned) current_event
.dwProcessId
,
1663 (unsigned) current_event
.dwThreadId
,
1664 "OUTPUT_DEBUG_STRING_EVENT"));
1665 if (saw_create
!= 1)
1667 thread_id
= handle_output_debug_string (ourstatus
);
1671 if (saw_create
!= 1)
1673 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1674 (unsigned) current_event
.dwProcessId
,
1675 (unsigned) current_event
.dwThreadId
);
1676 printf_unfiltered (" unknown event code %u\n",
1677 (unsigned) current_event
.dwDebugEventCode
);
1681 if (!thread_id
|| saw_create
!= 1)
1683 CHECK (windows_continue (continue_status
, -1, 0));
1687 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1688 current_thread
= th
;
1689 if (!current_thread
)
1690 current_thread
= thread_rec (thread_id
, TRUE
);
1697 /* Wait for interesting events to occur in the target process. */
1699 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1704 target_terminal::ours ();
1706 /* We loop when we get a non-standard exception rather than return
1707 with a SPURIOUS because resume can try and step or modify things,
1708 which needs a current_thread->h. But some of these exceptions mark
1709 the birth or death of threads, which mean that the current thread
1710 isn't necessarily what you think it is. */
1716 /* If the user presses Ctrl-c while the debugger is waiting
1717 for an event, he expects the debugger to interrupt his program
1718 and to get the prompt back. There are two possible situations:
1720 - The debugger and the program do not share the console, in
1721 which case the Ctrl-c event only reached the debugger.
1722 In that case, the ctrl_c handler will take care of interrupting
1723 the inferior. Note that this case is working starting with
1724 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1727 - The debugger and the program share the same console, in which
1728 case both debugger and inferior will receive the Ctrl-c event.
1729 In that case the ctrl_c handler will ignore the event, as the
1730 Ctrl-c event generated inside the inferior will trigger the
1731 expected debug event.
1733 FIXME: brobecker/2008-05-20: If the inferior receives the
1734 signal first and the delay until GDB receives that signal
1735 is sufficiently long, GDB can sometimes receive the SIGINT
1736 after we have unblocked the CTRL+C handler. This would
1737 lead to the debugger stopping prematurely while handling
1738 the new-thread event that comes with the handling of the SIGINT
1739 inside the inferior, and then stop again immediately when
1740 the user tries to resume the execution in the inferior.
1741 This is a classic race that we should try to fix one day. */
1742 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1743 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1744 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1747 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1752 if (deprecated_ui_loop_hook
!= NULL
)
1753 detach
= deprecated_ui_loop_hook (0);
1761 /* Iterate over all DLLs currently mapped by our inferior, and
1762 add them to our list of solibs. */
1765 windows_add_all_dlls (void)
1767 HMODULE dummy_hmodule
;
1772 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1773 sizeof (HMODULE
), &cb_needed
) == 0)
1779 hmodules
= (HMODULE
*) alloca (cb_needed
);
1780 if (EnumProcessModules (current_process_handle
, hmodules
,
1781 cb_needed
, &cb_needed
) == 0)
1784 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1788 wchar_t dll_name
[__PMAX
];
1791 char dll_name
[__PMAX
];
1794 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1795 &mi
, sizeof (mi
)) == 0)
1797 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1798 dll_name
, sizeof (dll_name
)) == 0)
1801 wcstombs (name
, dll_name
, __PMAX
);
1806 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1807 solib_end
= solib_end
->next
;
1812 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1815 struct inferior
*inf
;
1817 last_sig
= GDB_SIGNAL_0
;
1819 exception_count
= 0;
1820 open_process_used
= 0;
1821 debug_registers_changed
= 0;
1822 debug_registers_used
= 0;
1823 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1826 cygwin_load_start
= cygwin_load_end
= 0;
1828 current_event
.dwProcessId
= pid
;
1829 memset (¤t_event
, 0, sizeof (current_event
));
1830 if (!target_is_pushed (ops
))
1832 disable_breakpoints_in_shlibs ();
1833 windows_clear_solib ();
1834 clear_proceed_status (0);
1835 init_wait_for_inferior ();
1837 inf
= current_inferior ();
1838 inferior_appeared (inf
, pid
);
1839 inf
->attach_flag
= attaching
;
1841 /* Make the new process the current inferior, so terminal handling
1842 can rely on it. When attaching, we don't know about any thread
1843 id here, but that's OK --- nothing should be referencing the
1844 current thread until we report an event out of windows_wait. */
1845 inferior_ptid
= ptid_t (pid
);
1847 target_terminal::init ();
1848 target_terminal::inferior ();
1850 windows_initialization_done
= 0;
1854 struct target_waitstatus status
;
1856 ops
->wait (minus_one_ptid
, &status
, 0);
1858 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1860 if (status
.kind
!= TARGET_WAITKIND_LOADED
1861 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1864 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1867 /* Now that the inferior has been started and all DLLs have been mapped,
1868 we can iterate over all DLLs and load them in.
1870 We avoid doing it any earlier because, on certain versions of Windows,
1871 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1872 we have seen on Windows 8.1 that the ntdll.dll load event does not
1873 include the DLL name, preventing us from creating an associated SO.
1874 A possible explanation is that ntdll.dll might be mapped before
1875 the SO info gets created by the Windows system -- ntdll.dll is
1876 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1877 do not seem to suffer from that problem.
1879 Rather than try to work around this sort of issue, it is much
1880 simpler to just ignore DLL load/unload events during the startup
1881 phase, and then process them all in one batch now. */
1882 windows_add_all_dlls ();
1884 windows_initialization_done
= 1;
1888 /* Try to set or remove a user privilege to the current process. Return -1
1889 if that fails, the previous setting of that privilege otherwise.
1891 This code is copied from the Cygwin source code and rearranged to allow
1892 dynamically loading of the needed symbols from advapi32 which is only
1893 available on NT/2K/XP. */
1895 set_process_privilege (const char *privilege
, BOOL enable
)
1897 HANDLE token_hdl
= NULL
;
1899 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1903 if (!OpenProcessToken (GetCurrentProcess (),
1904 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1908 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1911 new_priv
.PrivilegeCount
= 1;
1912 new_priv
.Privileges
[0].Luid
= restore_priv
;
1913 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1915 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1916 sizeof orig_priv
, &orig_priv
, &size
))
1919 /* Disabled, otherwise every `attach' in an unprivileged user session
1920 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1921 windows_attach(). */
1922 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1923 be enabled. GetLastError () returns an correct error code, though. */
1924 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1928 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1932 CloseHandle (token_hdl
);
1937 /* Attach to process PID, then initialize for debugging it. */
1940 windows_nat_target::attach (const char *args
, int from_tty
)
1945 pid
= parse_pid_to_attach (args
);
1947 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1949 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1950 printf_unfiltered ("This can cause attach to "
1951 "fail on Windows NT/2K/XP\n");
1954 windows_init_thread_list ();
1955 ok
= DebugActiveProcess (pid
);
1961 /* Try fall back to Cygwin pid. */
1962 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1965 ok
= DebugActiveProcess (pid
);
1970 error (_("Can't attach to process."));
1972 DebugSetProcessKillOnExit (FALSE
);
1976 char *exec_file
= (char *) get_exec_file (0);
1979 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1980 target_pid_to_str (ptid_t (pid
)));
1982 printf_unfiltered ("Attaching to %s\n",
1983 target_pid_to_str (ptid_t (pid
)));
1985 gdb_flush (gdb_stdout
);
1988 do_initial_windows_stuff (this, pid
, 1);
1989 target_terminal::ours ();
1993 windows_nat_target::detach (inferior
*inf
, int from_tty
)
1997 ptid_t ptid
= minus_one_ptid
;
1998 resume (ptid
, 0, GDB_SIGNAL_0
);
2000 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2002 error (_("Can't detach process %u (error %u)"),
2003 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2006 DebugSetProcessKillOnExit (FALSE
);
2008 if (detached
&& from_tty
)
2010 const char *exec_file
= get_exec_file (0);
2013 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2014 (unsigned) current_event
.dwProcessId
);
2015 gdb_flush (gdb_stdout
);
2018 x86_cleanup_dregs ();
2019 inferior_ptid
= null_ptid
;
2020 detach_inferior (inf
);
2022 maybe_unpush_target ();
2025 /* Try to determine the executable filename.
2027 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2029 Upon success, the filename is stored inside EXE_NAME_RET, and
2030 this function returns nonzero.
2032 Otherwise, this function returns zero and the contents of
2033 EXE_NAME_RET is undefined. */
2036 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2043 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2044 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2047 /* We know the executable is always first in the list of modules,
2048 which we just fetched. So no need to fetch more. */
2052 /* Cygwin prefers that the path be in /x/y/z format, so extract
2053 the filename into a temporary buffer first, and then convert it
2054 to POSIX format into the destination buffer. */
2055 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2057 len
= GetModuleFileNameEx (current_process_handle
,
2058 dh_buf
, pathbuf
, exe_name_max_len
);
2060 error (_("Error getting executable filename: %u."),
2061 (unsigned) GetLastError ());
2062 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2063 exe_name_max_len
) < 0)
2064 error (_("Error converting executable filename to POSIX: %d."), errno
);
2067 len
= GetModuleFileNameEx (current_process_handle
,
2068 dh_buf
, exe_name_ret
, exe_name_max_len
);
2070 error (_("Error getting executable filename: %u."),
2071 (unsigned) GetLastError ());
2074 return 1; /* success */
2077 /* The pid_to_exec_file target_ops method for this platform. */
2080 windows_nat_target::pid_to_exec_file (int pid
)
2082 static char path
[__PMAX
];
2084 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2086 char procexe
[sizeof ("/proc/4294967295/exe")];
2088 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2089 nchars
= readlink (procexe
, path
, sizeof(path
));
2090 if (nchars
> 0 && nchars
< sizeof (path
))
2092 path
[nchars
] = '\0'; /* Got it */
2097 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2098 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2099 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2105 /* Print status information about what we're accessing. */
2108 windows_nat_target::files_info ()
2110 struct inferior
*inf
= current_inferior ();
2112 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2113 inf
->attach_flag
? "attached" : "child",
2114 target_pid_to_str (inferior_ptid
));
2117 /* Modify CreateProcess parameters for use of a new separate console.
2119 *FLAGS: DWORD parameter for general process creation flags.
2120 *SI: STARTUPINFO structure, for which the console window size and
2121 console buffer size is filled in if GDB is running in a console.
2122 to create the new console.
2123 The size of the used font is not available on all versions of
2124 Windows OS. Furthermore, the current font might not be the default
2125 font, but this is still better than before.
2126 If the windows and buffer sizes are computed,
2127 SI->DWFLAGS is changed so that this information is used
2128 by CreateProcess function. */
2131 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2133 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2134 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2136 if (hconsole
!= INVALID_HANDLE_VALUE
)
2138 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2140 CONSOLE_FONT_INFO cfi
;
2142 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2143 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2144 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2145 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2146 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2148 si
->dwXSize
*= font_size
.X
;
2152 si
->dwYSize
*= font_size
.Y
;
2155 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2156 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2157 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2159 *flags
|= CREATE_NEW_CONSOLE
;
2163 /* Function called by qsort to sort environment strings. */
2166 envvar_cmp (const void *a
, const void *b
)
2168 const char **p
= (const char **) a
;
2169 const char **q
= (const char **) b
;
2170 return strcasecmp (*p
, *q
);
2176 clear_win32_environment (char **env
)
2180 wchar_t *copy
= NULL
, *equalpos
;
2182 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2184 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2185 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2186 mbstowcs (copy
, env
[i
], len
);
2187 equalpos
= wcschr (copy
, L
'=');
2190 SetEnvironmentVariableW (copy
, NULL
);
2198 /* Redirection of inferior I/O streams for native MS-Windows programs.
2199 Unlike on Unix, where this is handled by invoking the inferior via
2200 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2202 The official documentation of the cmd.exe redirection features is here:
2204 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2206 (That page talks about Windows XP, but there's no newer
2207 documentation, so we assume later versions of cmd.exe didn't change
2210 Caveat: the documentation on that page seems to include a few lies.
2211 For example, it describes strange constructs 1<&2 and 2<&1, which
2212 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2213 think the cmd.exe parser of the redirection symbols simply doesn't
2214 care about the < vs > distinction in these cases. Therefore, the
2215 supported features are explicitly documented below.
2217 The emulation below aims at supporting all the valid use cases
2218 supported by cmd.exe, which include:
2220 < FILE redirect standard input from FILE
2221 0< FILE redirect standard input from FILE
2222 <&N redirect standard input from file descriptor N
2223 0<&N redirect standard input from file descriptor N
2224 > FILE redirect standard output to FILE
2225 >> FILE append standard output to FILE
2226 1>> FILE append standard output to FILE
2227 >&N redirect standard output to file descriptor N
2228 1>&N redirect standard output to file descriptor N
2229 >>&N append standard output to file descriptor N
2230 1>>&N append standard output to file descriptor N
2231 2> FILE redirect standard error to FILE
2232 2>> FILE append standard error to FILE
2233 2>&N redirect standard error to file descriptor N
2234 2>>&N append standard error to file descriptor N
2236 Note that using N > 2 in the above construct is supported, but
2237 requires that the corresponding file descriptor be open by some
2238 means elsewhere or outside GDB. Also note that using ">&0" or
2239 "<&2" will generally fail, because the file descriptor redirected
2240 from is normally open in an incompatible mode (e.g., FD 0 is open
2241 for reading only). IOW, use of such tricks is not recommended;
2242 you are on your own.
2244 We do NOT support redirection of file descriptors above 2, as in
2245 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2246 that needs special handling in the startup code that MinGW
2247 doesn't have). Pipes are also not supported.
2249 As for invalid use cases, where the redirection contains some
2250 error, the emulation below will detect that and produce some
2251 error and/or failure. But the behavior in those cases is not
2252 bug-for-bug compatible with what cmd.exe does in those cases.
2253 That's because what cmd.exe does then is not well defined, and
2254 seems to be a side effect of the cmd.exe parsing of the command
2255 line more than anything else. For example, try redirecting to an
2256 invalid file name, as in "> foo:bar".
2258 There are also minor syntactic deviations from what cmd.exe does
2259 in some corner cases. For example, it doesn't support the likes
2260 of "> &foo" to mean redirect to file named literally "&foo"; we
2261 do support that here, because that, too, sounds like some issue
2262 with the cmd.exe parser. Another nicety is that we support
2263 redirection targets that use file names with forward slashes,
2264 something cmd.exe doesn't -- this comes in handy since GDB
2265 file-name completion can be used when typing the command line for
2268 /* Support routines for redirecting standard handles of the inferior. */
2270 /* Parse a single redirection spec, open/duplicate the specified
2271 file/fd, and assign the appropriate value to one of the 3 standard
2272 file descriptors. */
2274 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2276 int *fd
, ref_fd
= -2;
2278 const char *fname
= redir_string
+ 1;
2279 int rc
= *redir_string
;
2294 fd
= (rc
== '2') ? err
: out
;
2295 mode
= O_WRONLY
| O_CREAT
;
2308 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2310 /* A reference to a file descriptor. */
2312 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2313 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2315 /* Don't allow redirection when open modes are incompatible. */
2316 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2317 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2324 else if (ref_fd
== 1)
2326 else if (ref_fd
== 2)
2336 fname
++; /* skip the separator space */
2337 /* If the descriptor is already open, close it. This allows
2338 multiple specs of redirections for the same stream, which is
2339 somewhat nonsensical, but still valid and supported by cmd.exe.
2340 (But cmd.exe only opens a single file in this case, the one
2341 specified by the last redirection spec on the command line.) */
2346 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2350 else if (ref_fd
== -1)
2351 *fd
= -1; /* reset to default destination */
2354 *fd
= _dup (ref_fd
);
2358 /* _open just sets a flag for O_APPEND, which won't be passed to the
2359 inferior, so we need to actually move the file pointer. */
2360 if ((mode
& O_APPEND
) != 0)
2361 _lseek (*fd
, 0L, SEEK_END
);
2365 /* Canonicalize a single redirection spec and set up the corresponding
2366 file descriptor as specified. */
2368 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2370 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2372 const char *start
= s
;
2375 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2376 if ((*start
== '>' || *start
== '1' || *start
== '2')
2380 if (*s
== '>' && *start
!= '>')
2383 else if (*start
== '0' && *s
== '<')
2385 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2388 while (isspace (*s
)) /* skip whitespace before file name */
2390 *d
++ = ' '; /* separate file name with a single space */
2393 /* Copy the file name. */
2396 /* Remove quoting characters from the file name in buf[]. */
2397 if (*s
== '"') /* could support '..' quoting here */
2401 else if (*s
== quote
)
2409 else if (*s
== '\\')
2411 if (s
[1] == '"') /* could support '..' here */
2415 else if (isspace (*s
) && !quote
)
2419 if (d
- buf
>= sizeof (buf
) - 1)
2421 errno
= ENAMETOOLONG
;
2427 /* Windows doesn't allow redirection characters in file names, so we
2428 can bail out early if they use them, or if there's no target file
2429 name after the redirection symbol. */
2430 if (d
[-1] == '>' || d
[-1] == '<')
2435 if (redir_open (buf
, inp
, out
, err
) == 0)
2440 /* Parse the command line for redirection specs and prepare the file
2441 descriptors for the 3 standard streams accordingly. */
2443 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2444 int *inp
, int *out
, int *err
)
2446 const char *s
= cmd_orig
;
2449 bool retval
= false;
2451 while (isspace (*s
))
2456 if (*s
== '"') /* could also support '..' quoting here */
2460 else if (*s
== quote
)
2463 else if (*s
== '\\')
2465 if (s
[1] == '"') /* escaped quote char */
2470 /* Process a single redirection candidate. */
2471 if (*s
== '<' || *s
== '>'
2472 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2473 || (*s
== '0' && s
[1] == '<'))
2475 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2489 #endif /* !__CYGWIN__ */
2491 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2492 EXEC_FILE is the file to run.
2493 ALLARGS is a string containing the arguments to the program.
2494 ENV is the environment vector to pass. Errors reported with error(). */
2497 windows_nat_target::create_inferior (const char *exec_file
,
2498 const std::string
&origallargs
,
2499 char **in_env
, int from_tty
)
2503 cygwin_buf_t real_path
[__PMAX
];
2504 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2505 cygwin_buf_t infcwd
[__PMAX
];
2507 cygwin_buf_t
*toexec
;
2508 cygwin_buf_t
*cygallargs
;
2510 char **old_env
= NULL
;
2514 int ostdin
, ostdout
, ostderr
;
2515 #else /* !__CYGWIN__ */
2516 char shell
[__PMAX
]; /* Path to shell */
2518 char *args
, *allargs_copy
;
2519 size_t args_len
, allargs_len
;
2520 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2521 HANDLE tty
= INVALID_HANDLE_VALUE
;
2522 bool redirected
= false;
2529 #endif /* !__CYGWIN__ */
2530 const char *allargs
= origallargs
.c_str ();
2531 PROCESS_INFORMATION pi
;
2534 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2537 error (_("No executable specified, use `target exec'."));
2539 const char *inferior_cwd
= get_inferior_cwd ();
2540 std::string expanded_infcwd
;
2541 if (inferior_cwd
!= NULL
)
2543 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2544 /* Mirror slashes on inferior's cwd. */
2545 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2547 inferior_cwd
= expanded_infcwd
.c_str ();
2550 memset (&si
, 0, sizeof (si
));
2551 si
.cb
= sizeof (si
);
2554 flags
|= CREATE_NEW_PROCESS_GROUP
;
2557 windows_set_console_info (&si
, &flags
);
2562 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2563 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2564 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2565 error (_("Error starting executable: %d"), errno
);
2568 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2569 if (len
== (size_t) -1)
2570 error (_("Error starting executable: %d"), errno
);
2571 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2572 mbstowcs (cygallargs
, allargs
, len
);
2573 #else /* !__USEWIDE */
2574 cygallargs
= allargs
;
2579 sh
= getenv ("SHELL");
2582 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2583 error (_("Error starting executable via shell: %d"), errno
);
2585 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2586 + mbstowcs (NULL
, allargs
, 0) + 2;
2587 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2588 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2589 #else /* !__USEWIDE */
2590 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2591 + strlen (allargs
) + 2);
2592 cygallargs
= (char *) alloca (len
);
2593 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2594 #endif /* __USEWIDE */
2596 flags
|= DEBUG_PROCESS
;
2599 if (inferior_cwd
!= NULL
2600 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2601 infcwd
, strlen (inferior_cwd
)) < 0)
2602 error (_("Error converting inferior cwd: %d"), errno
);
2605 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2606 * sizeof (wchar_t));
2607 wcscpy (args
, toexec
);
2608 wcscat (args
, L
" ");
2609 wcscat (args
, cygallargs
);
2610 #else /* !__USEWIDE */
2611 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2612 strcpy (args
, toexec
);
2614 strcat (args
, cygallargs
);
2615 #endif /* !__USEWIDE */
2617 #ifdef CW_CVT_ENV_TO_WINENV
2618 /* First try to create a direct Win32 copy of the POSIX environment. */
2619 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2620 if (w32_env
!= (PWCHAR
) -1)
2621 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2623 /* If that fails, fall back to old method tweaking GDB's environment. */
2624 #endif /* CW_CVT_ENV_TO_WINENV */
2626 /* Reset all Win32 environment variables to avoid leftover on next run. */
2627 clear_win32_environment (environ
);
2628 /* Prepare the environment vars for CreateProcess. */
2631 cygwin_internal (CW_SYNC_WINENV
);
2635 if (!inferior_io_terminal
)
2636 tty
= ostdin
= ostdout
= ostderr
= -1;
2639 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2642 print_sys_errmsg (inferior_io_terminal
, errno
);
2643 ostdin
= ostdout
= ostderr
= -1;
2656 windows_init_thread_list ();
2657 ret
= CreateProcess (0,
2658 args
, /* command line */
2659 NULL
, /* Security */
2661 TRUE
, /* inherit handles */
2662 flags
, /* start flags */
2663 w32_env
, /* environment */
2664 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2669 /* Just free the Win32 environment, if it could be created. */
2673 /* Reset all environment variables to avoid leftover on next run. */
2674 clear_win32_environment (in_env
);
2675 /* Restore normal GDB environment variables. */
2677 cygwin_internal (CW_SYNC_WINENV
);
2690 #else /* !__CYGWIN__ */
2691 allargs_len
= strlen (allargs
);
2692 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2693 if (strpbrk (allargs_copy
, "<>") != NULL
)
2698 redirect_inferior_handles (allargs
, allargs_copy
,
2699 &fd_inp
, &fd_out
, &fd_err
);
2701 warning (_("Error in redirection: %s."), strerror (errno
));
2704 allargs_len
= strlen (allargs_copy
);
2706 /* If not all the standard streams are redirected by the command
2707 line, use inferior_io_terminal for those which aren't. */
2708 if (inferior_io_terminal
2709 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2711 SECURITY_ATTRIBUTES sa
;
2712 sa
.nLength
= sizeof(sa
);
2713 sa
.lpSecurityDescriptor
= 0;
2714 sa
.bInheritHandle
= TRUE
;
2715 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2716 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2717 if (tty
== INVALID_HANDLE_VALUE
)
2718 warning (_("Warning: Failed to open TTY %s, error %#x."),
2719 inferior_io_terminal
, (unsigned) GetLastError ());
2721 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2724 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2725 else if (tty
!= INVALID_HANDLE_VALUE
)
2728 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2730 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2731 else if (tty
!= INVALID_HANDLE_VALUE
)
2732 si
.hStdOutput
= tty
;
2734 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2736 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2737 else if (tty
!= INVALID_HANDLE_VALUE
)
2740 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2741 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2745 /* Build the command line, a space-separated list of tokens where
2746 the first token is the name of the module to be executed.
2747 To avoid ambiguities introduced by spaces in the module name,
2749 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2750 args
= (char *) alloca (args_len
);
2751 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2753 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2755 /* CreateProcess takes the environment list as a null terminated set of
2756 strings (i.e. two nulls terminate the list). */
2758 /* Get total size for env strings. */
2759 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2760 envlen
+= strlen (in_env
[i
]) + 1;
2762 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2763 env
= (char **) alloca (envsize
);
2764 memcpy (env
, in_env
, envsize
);
2765 /* Windows programs expect the environment block to be sorted. */
2766 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2768 w32env
= (char *) alloca (envlen
+ 1);
2770 /* Copy env strings into new buffer. */
2771 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2773 strcpy (temp
, env
[i
]);
2774 temp
+= strlen (temp
) + 1;
2777 /* Final nil string to terminate new env. */
2780 windows_init_thread_list ();
2781 ret
= CreateProcessA (0,
2782 args
, /* command line */
2783 NULL
, /* Security */
2785 TRUE
, /* inherit handles */
2786 flags
, /* start flags */
2787 w32env
, /* environment */
2788 inferior_cwd
, /* current directory */
2791 if (tty
!= INVALID_HANDLE_VALUE
)
2799 #endif /* !__CYGWIN__ */
2802 error (_("Error creating process %s, (error %u)."),
2803 exec_file
, (unsigned) GetLastError ());
2805 CloseHandle (pi
.hThread
);
2806 CloseHandle (pi
.hProcess
);
2808 if (useshell
&& shell
[0] != '\0')
2813 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2815 /* windows_continue (DBG_CONTINUE, -1, 0); */
2819 windows_nat_target::mourn_inferior ()
2821 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2822 x86_cleanup_dregs();
2823 if (open_process_used
)
2825 CHECK (CloseHandle (current_process_handle
));
2826 open_process_used
= 0;
2828 inf_child_target::mourn_inferior ();
2831 /* Send a SIGINT to the process group. This acts just like the user typed a
2832 ^C on the controlling terminal. */
2835 windows_nat_target::interrupt ()
2837 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2838 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2839 registers_changed (); /* refresh register state */
2842 /* Helper for windows_xfer_partial that handles memory transfers.
2843 Arguments are like target_xfer_partial. */
2845 static enum target_xfer_status
2846 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2847 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2851 DWORD lasterror
= 0;
2853 if (writebuf
!= NULL
)
2855 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2856 pulongest (len
), core_addr_to_string (memaddr
)));
2857 success
= WriteProcessMemory (current_process_handle
,
2858 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2861 lasterror
= GetLastError ();
2862 FlushInstructionCache (current_process_handle
,
2863 (LPCVOID
) (uintptr_t) memaddr
, len
);
2867 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2868 pulongest (len
), core_addr_to_string (memaddr
)));
2869 success
= ReadProcessMemory (current_process_handle
,
2870 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2873 lasterror
= GetLastError ();
2875 *xfered_len
= (ULONGEST
) done
;
2876 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2877 return TARGET_XFER_OK
;
2879 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2883 windows_nat_target::kill ()
2885 CHECK (TerminateProcess (current_process_handle
, 0));
2889 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2891 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2893 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2897 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2901 windows_nat_target::close ()
2903 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2904 inferior_ptid
.pid ()));
2907 /* Convert pid to printable format. */
2909 windows_nat_target::pid_to_str (ptid_t ptid
)
2911 static char buf
[80];
2913 if (ptid
.tid () != 0)
2915 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2916 ptid
.pid (), ptid
.tid ());
2920 return normal_pid_to_str (ptid
);
2923 static enum target_xfer_status
2924 windows_xfer_shared_libraries (struct target_ops
*ops
,
2925 enum target_object object
, const char *annex
,
2926 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2927 ULONGEST offset
, ULONGEST len
,
2928 ULONGEST
*xfered_len
)
2930 struct obstack obstack
;
2936 return TARGET_XFER_E_IO
;
2938 obstack_init (&obstack
);
2939 obstack_grow_str (&obstack
, "<library-list>\n");
2940 for (so
= solib_start
.next
; so
; so
= so
->next
)
2942 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2944 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2945 (uintptr_t) li
->load_addr
,
2946 target_gdbarch (), &obstack
);
2948 obstack_grow_str0 (&obstack
, "</library-list>\n");
2950 buf
= (const char *) obstack_finish (&obstack
);
2951 len_avail
= strlen (buf
);
2952 if (offset
>= len_avail
)
2956 if (len
> len_avail
- offset
)
2957 len
= len_avail
- offset
;
2958 memcpy (readbuf
, buf
+ offset
, len
);
2961 obstack_free (&obstack
, NULL
);
2962 *xfered_len
= (ULONGEST
) len
;
2963 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2966 enum target_xfer_status
2967 windows_nat_target::xfer_partial (enum target_object object
,
2968 const char *annex
, gdb_byte
*readbuf
,
2969 const gdb_byte
*writebuf
, ULONGEST offset
,
2970 ULONGEST len
, ULONGEST
*xfered_len
)
2974 case TARGET_OBJECT_MEMORY
:
2975 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2977 case TARGET_OBJECT_LIBRARIES
:
2978 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2979 writebuf
, offset
, len
, xfered_len
);
2982 if (beneath () == NULL
)
2984 /* This can happen when requesting the transfer of unsupported
2985 objects before a program has been started (and therefore
2986 with the current_target having no target beneath). */
2987 return TARGET_XFER_E_IO
;
2989 return beneath ()->xfer_partial (object
, annex
,
2990 readbuf
, writebuf
, offset
, len
,
2995 /* Provide thread local base, i.e. Thread Information Block address.
2996 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2999 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3001 windows_thread_info
*th
;
3003 th
= thread_rec (ptid
.tid (), 0);
3008 *addr
= th
->thread_local_base
;
3014 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3016 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3019 /* Implementation of the to_thread_name method. */
3022 windows_nat_target::thread_name (struct thread_info
*thr
)
3024 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3029 _initialize_windows_nat (void)
3031 x86_dr_low
.set_control
= cygwin_set_dr7
;
3032 x86_dr_low
.set_addr
= cygwin_set_dr
;
3033 x86_dr_low
.get_addr
= cygwin_get_dr
;
3034 x86_dr_low
.get_status
= cygwin_get_dr6
;
3035 x86_dr_low
.get_control
= cygwin_get_dr7
;
3037 /* x86_dr_low.debug_register_length field is set by
3038 calling x86_set_debug_register_length function
3039 in processor windows specific native file. */
3041 add_inf_child_target (&the_windows_nat_target
);
3044 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3047 add_com ("signal-event", class_run
, signal_event_command
, _("\
3048 Signal a crashed process with event ID, to allow its debugging.\n\
3049 This command is needed in support of setting up GDB as JIT debugger on \
3050 MS-Windows. The command should be invoked from the GDB command line using \
3051 the '-ex' command-line option. The ID of the event that blocks the \
3052 crashed process will be supplied by the Windows JIT debugging mechanism."));
3055 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3056 Set use of shell to start subprocess."), _("\
3057 Show use of shell to start subprocess."), NULL
,
3059 NULL
, /* FIXME: i18n: */
3060 &setlist
, &showlist
);
3062 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3063 &cygwin_exceptions
, _("\
3064 Break when an exception is detected in the Cygwin DLL itself."), _("\
3065 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3067 NULL
, /* FIXME: i18n: */
3068 &setlist
, &showlist
);
3071 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3072 Set creation of new console when creating child process."), _("\
3073 Show creation of new console when creating child process."), NULL
,
3075 NULL
, /* FIXME: i18n: */
3076 &setlist
, &showlist
);
3078 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3079 Set creation of new group when creating child process."), _("\
3080 Show creation of new group when creating child process."), NULL
,
3082 NULL
, /* FIXME: i18n: */
3083 &setlist
, &showlist
);
3085 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3086 Set whether to display execution in child process."), _("\
3087 Show whether to display execution in child process."), NULL
,
3089 NULL
, /* FIXME: i18n: */
3090 &setlist
, &showlist
);
3092 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3093 Set whether to display kernel events in child process."), _("\
3094 Show whether to display kernel events in child process."), NULL
,
3096 NULL
, /* FIXME: i18n: */
3097 &setlist
, &showlist
);
3099 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3100 Set whether to display memory accesses in child process."), _("\
3101 Show whether to display memory accesses in child process."), NULL
,
3103 NULL
, /* FIXME: i18n: */
3104 &setlist
, &showlist
);
3106 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3107 &debug_exceptions
, _("\
3108 Set whether to display kernel exceptions in child process."), _("\
3109 Show whether to display kernel exceptions in child process."), NULL
,
3111 NULL
, /* FIXME: i18n: */
3112 &setlist
, &showlist
);
3114 init_w32_command_list ();
3116 add_cmd ("selector", class_info
, display_selectors
,
3117 _("Display selectors infos."),
3121 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3123 /* Pass the address ADDR to the inferior in the I'th debug register.
3124 Here we just store the address in dr array, the registers will be
3125 actually set up when windows_continue is called. */
3127 cygwin_set_dr (int i
, CORE_ADDR addr
)
3130 internal_error (__FILE__
, __LINE__
,
3131 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3133 debug_registers_changed
= 1;
3134 debug_registers_used
= 1;
3137 /* Pass the value VAL to the inferior in the DR7 debug control
3138 register. Here we just store the address in D_REGS, the watchpoint
3139 will be actually set up in windows_wait. */
3141 cygwin_set_dr7 (unsigned long val
)
3143 dr
[7] = (CORE_ADDR
) val
;
3144 debug_registers_changed
= 1;
3145 debug_registers_used
= 1;
3148 /* Get the value of debug register I from the inferior. */
3151 cygwin_get_dr (int i
)
3156 /* Get the value of the DR6 debug status register from the inferior.
3157 Here we just return the value stored in dr[6]
3158 by the last call to thread_rec for current_event.dwThreadId id. */
3159 static unsigned long
3160 cygwin_get_dr6 (void)
3162 return (unsigned long) dr
[6];
3165 /* Get the value of the DR7 debug status register from the inferior.
3166 Here we just return the value stored in dr[7] by the last call to
3167 thread_rec for current_event.dwThreadId id. */
3169 static unsigned long
3170 cygwin_get_dr7 (void)
3172 return (unsigned long) dr
[7];
3175 /* Determine if the thread referenced by "ptid" is alive
3176 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3177 it means that the thread has died. Otherwise it is assumed to be alive. */
3180 windows_nat_target::thread_alive (ptid_t ptid
)
3184 gdb_assert (ptid
.tid () != 0);
3187 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3191 _initialize_check_for_gdb_ini (void)
3194 if (inhibit_gdbinit
)
3197 homedir
= getenv ("HOME");
3201 char *oldini
= (char *) alloca (strlen (homedir
) +
3202 sizeof ("gdb.ini") + 1);
3203 strcpy (oldini
, homedir
);
3204 p
= strchr (oldini
, '\0');
3205 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3207 strcpy (p
, "gdb.ini");
3208 if (access (oldini
, 0) == 0)
3210 int len
= strlen (oldini
);
3211 char *newini
= (char *) alloca (len
+ 2);
3213 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3214 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3215 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3220 /* Define dummy functions which always return error for the rare cases where
3221 these functions could not be found. */
3223 bad_DebugActiveProcessStop (DWORD w
)
3228 bad_DebugBreakProcess (HANDLE w
)
3233 bad_DebugSetProcessKillOnExit (BOOL w
)
3238 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3245 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3251 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3258 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3264 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3270 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3276 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3284 /* Load any functions which may not be available in ancient versions
3288 _initialize_loadable (void)
3292 #define GPA(m, func) \
3293 func = (func ## _ftype *) GetProcAddress (m, #func)
3295 hm
= LoadLibrary ("kernel32.dll");
3298 GPA (hm
, DebugActiveProcessStop
);
3299 GPA (hm
, DebugBreakProcess
);
3300 GPA (hm
, DebugSetProcessKillOnExit
);
3301 GPA (hm
, GetConsoleFontSize
);
3302 GPA (hm
, DebugActiveProcessStop
);
3303 GPA (hm
, GetCurrentConsoleFont
);
3306 /* Set variables to dummy versions of these processes if the function
3307 wasn't found in kernel32.dll. */
3308 if (!DebugBreakProcess
)
3309 DebugBreakProcess
= bad_DebugBreakProcess
;
3310 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3312 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3313 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3315 if (!GetConsoleFontSize
)
3316 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3317 if (!GetCurrentConsoleFont
)
3318 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3320 /* Load optional functions used for retrieving filename information
3321 associated with the currently debugged process or its dlls. */
3322 hm
= LoadLibrary ("psapi.dll");
3325 GPA (hm
, EnumProcessModules
);
3326 GPA (hm
, GetModuleInformation
);
3327 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3328 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3331 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3333 /* Set variables to dummy versions of these processes if the function
3334 wasn't found in psapi.dll. */
3335 EnumProcessModules
= bad_EnumProcessModules
;
3336 GetModuleInformation
= bad_GetModuleInformation
;
3337 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3338 /* This will probably fail on Windows 9x/Me. Let the user know
3339 that we're missing some functionality. */
3341 cannot automatically find executable file or library to read symbols.\n\
3342 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3345 hm
= LoadLibrary ("advapi32.dll");
3348 GPA (hm
, OpenProcessToken
);
3349 GPA (hm
, LookupPrivilegeValueA
);
3350 GPA (hm
, AdjustTokenPrivileges
);
3351 /* Only need to set one of these since if OpenProcessToken fails nothing
3353 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3354 || !AdjustTokenPrivileges
)
3355 OpenProcessToken
= bad_OpenProcessToken
;