1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2018 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdb_tilde_expand.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
85 DWORD
, PTOKEN_PRIVILEGES
,
87 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
89 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
90 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
92 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
93 static DebugBreakProcess_ftype
*DebugBreakProcess
;
95 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
96 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
98 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
100 static EnumProcessModules_ftype
*EnumProcessModules
;
102 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
103 LPMODULEINFO
, DWORD
);
104 static GetModuleInformation_ftype
*GetModuleInformation
;
106 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
107 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
109 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
110 static OpenProcessToken_ftype
*OpenProcessToken
;
112 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
113 CONSOLE_FONT_INFO
*);
114 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
116 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
117 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
121 #undef GetModuleFileNameEx
124 # define __PMAX (MAX_PATH + 1)
125 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
126 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
127 # define STARTUPINFO STARTUPINFOA
128 # define CreateProcess CreateProcessA
129 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
130 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
132 # define __PMAX PATH_MAX
133 /* The starting and ending address of the cygwin1.dll text segment. */
134 static CORE_ADDR cygwin_load_start
;
135 static CORE_ADDR cygwin_load_end
;
137 typedef wchar_t cygwin_buf_t
;
138 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
140 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
141 # define STARTUPINFO STARTUPINFOW
142 # define CreateProcess CreateProcessW
143 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
144 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
147 static int have_saved_context
; /* True if we've saved context from a
149 static CONTEXT saved_context
; /* Containes the saved context from a
152 /* If we're not using the old Cygwin header file set, define the
153 following which never should have been in the generic Win32 API
154 headers in the first place since they were our own invention... */
155 #ifndef _GNU_H_WINDOWS_H
158 FLAG_TRACE_BIT
= 0x100,
162 #ifndef CONTEXT_EXTENDED_REGISTERS
163 /* This macro is only defined on ia32. It only makes sense on this target,
164 so define it as zero if not already defined. */
165 #define CONTEXT_EXTENDED_REGISTERS 0
168 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
169 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
170 | CONTEXT_EXTENDED_REGISTERS
172 static uintptr_t dr
[8];
173 static int debug_registers_changed
;
174 static int debug_registers_used
;
176 static int windows_initialization_done
;
177 #define DR6_CLEAR_VALUE 0xffff0ff0
179 /* The exception thrown by a program to tell the debugger the name of
180 a thread. The exception record contains an ID of a thread and a
181 name to give it. This exception has no documented name, but MSDN
182 dubs it "MS_VC_EXCEPTION" in one code example. */
183 #define MS_VC_EXCEPTION 0x406d1388
187 HANDLE_EXCEPTION_UNHANDLED
= 0,
188 HANDLE_EXCEPTION_HANDLED
,
189 HANDLE_EXCEPTION_IGNORED
190 } handle_exception_result
;
192 /* The string sent by cygwin when it processes a signal.
193 FIXME: This should be in a cygwin include file. */
194 #ifndef _CYGWIN_SIGNAL_STRING
195 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
198 #define CHECK(x) check (x, __FILE__,__LINE__)
199 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
200 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
201 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
202 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
204 static void 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_get_tid (ptid
) != 0);
432 id
= ptid_get_tid (ptid
);
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_get_tid (ptid
) != 0);
489 id
= ptid_get_tid (ptid
);
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 (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
;
513 do_windows_fetch_inferior_registers (struct regcache
*regcache
,
514 windows_thread_info
*th
, int r
)
516 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
517 struct gdbarch
*gdbarch
= regcache
->arch ();
518 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
521 if (th
->reload_context
)
524 if (have_saved_context
)
526 /* Lie about where the program actually is stopped since
527 cygwin has informed us that we should consider the signal
528 to have occurred at another location which is stored in
530 memcpy (&th
->context
, &saved_context
,
531 __COPY_CONTEXT_SIZE
);
532 have_saved_context
= 0;
537 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
538 CHECK (GetThreadContext (th
->h
, &th
->context
));
539 /* Copy dr values from that thread.
540 But only if there were not modified since last stop.
542 if (!debug_registers_changed
)
544 dr
[0] = th
->context
.Dr0
;
545 dr
[1] = th
->context
.Dr1
;
546 dr
[2] = th
->context
.Dr2
;
547 dr
[3] = th
->context
.Dr3
;
548 dr
[6] = th
->context
.Dr6
;
549 dr
[7] = th
->context
.Dr7
;
552 th
->reload_context
= 0;
555 if (r
== I387_FISEG_REGNUM (tdep
))
557 l
= *((long *) context_offset
) & 0xffff;
558 regcache_raw_supply (regcache
, r
, (char *) &l
);
560 else if (r
== I387_FOP_REGNUM (tdep
))
562 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
563 regcache_raw_supply (regcache
, r
, (char *) &l
);
565 else if (segment_register_p (r
))
567 /* GDB treats segment registers as 32bit registers, but they are
568 in fact only 16 bits long. Make sure we do not read extra
569 bits from our source buffer. */
570 l
= *((long *) context_offset
) & 0xffff;
571 regcache_raw_supply (regcache
, r
, (char *) &l
);
574 regcache_raw_supply (regcache
, r
, context_offset
);
577 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
578 do_windows_fetch_inferior_registers (regcache
, th
, r
);
583 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
585 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
586 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
588 /* Check if TH exists. Windows sometimes uses a non-existent
589 thread id in its events. */
591 do_windows_fetch_inferior_registers (regcache
, th
, r
);
595 do_windows_store_inferior_registers (const struct regcache
*regcache
,
596 windows_thread_info
*th
, int r
)
599 regcache_raw_collect (regcache
, r
,
600 ((char *) &th
->context
) + mappings
[r
]);
603 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
604 do_windows_store_inferior_registers (regcache
, th
, r
);
608 /* Store a new register value into the context of the thread tied to
612 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
614 DWORD pid
= ptid_get_tid (regcache_get_ptid (regcache
));
615 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
617 /* Check if TH exists. Windows sometimes uses a non-existent
618 thread id in its events. */
620 do_windows_store_inferior_registers (regcache
, th
, r
);
623 /* Encapsulate the information required in a call to
624 symbol_file_add_args. */
625 struct safe_symbol_file_add_args
629 section_addr_info
*addrs
;
632 struct ui_file
*err
, *out
;
636 /* Maintain a linked list of "so" information. */
637 struct lm_info_windows
: public lm_info_base
639 LPVOID load_addr
= 0;
642 static struct so_list solib_start
, *solib_end
;
644 static struct so_list
*
645 windows_make_so (const char *name
, LPVOID load_addr
)
652 WIN32_FIND_DATA w32_fd
;
653 HANDLE h
= FindFirstFile(name
, &w32_fd
);
655 if (h
== INVALID_HANDLE_VALUE
)
661 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
663 p
= strrchr (buf
, '\\');
666 SetCurrentDirectory (buf
);
667 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
668 SetCurrentDirectory (cwd
);
671 if (strcasecmp (buf
, "ntdll.dll") == 0)
673 GetSystemDirectory (buf
, sizeof (buf
));
674 strcat (buf
, "\\ntdll.dll");
677 cygwin_buf_t buf
[__PMAX
];
680 if (access (name
, F_OK
) != 0)
682 if (strcasecmp (name
, "ntdll.dll") == 0)
685 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
686 wcscat (buf
, L
"\\ntdll.dll");
690 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
691 strcat (buf
, "\\ntdll.dll");
696 so
= XCNEW (struct so_list
);
697 lm_info_windows
*li
= new lm_info_windows
;
699 li
->load_addr
= load_addr
;
700 strcpy (so
->so_original_name
, name
);
702 strcpy (so
->so_name
, buf
);
705 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
706 SO_NAME_MAX_PATH_SIZE
);
709 char *rname
= realpath (name
, NULL
);
710 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
712 strcpy (so
->so_name
, rname
);
716 error (_("dll path too long"));
718 /* Record cygwin1.dll .text start/end. */
719 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
720 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
722 asection
*text
= NULL
;
725 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
730 if (bfd_check_format (abfd
.get (), bfd_object
))
731 text
= bfd_get_section_by_name (abfd
.get (), ".text");
736 /* The symbols in a dll are offset by 0x1000, which is the
737 offset from 0 of the first byte in an image - because of the
738 file header and the section alignment. */
739 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
741 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
750 get_image_name (HANDLE h
, void *address
, int unicode
)
753 static char buf
[__PMAX
];
755 static char buf
[(2 * __PMAX
) + 1];
757 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
763 /* Attempt to read the name of the dll that was detected.
764 This is documented to work only when actively debugging
765 a program. It will not work for attached processes. */
769 /* See if we could read the address of a string, and that the
770 address isn't null. */
771 if (!ReadProcessMemory (h
, address
, &address_ptr
,
772 sizeof (address_ptr
), &done
)
773 || done
!= sizeof (address_ptr
) || !address_ptr
)
776 /* Find the length of the string. */
777 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
778 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
782 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
785 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
786 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
789 wcstombs (buf
, unicode_address
, __PMAX
);
791 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
799 /* Handle a DLL load event, and return 1.
801 This function assumes that this event did not occur during inferior
802 initialization, where their event info may be incomplete (see
803 do_initial_windows_stuff and windows_add_all_dlls for more info
804 on how we handle DLL loading during that phase). */
809 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
812 /* Try getting the DLL name via the lpImageName field of the event.
813 Note that Microsoft documents this fields as strictly optional,
814 in the sense that it might be NULL. And the first DLL event in
815 particular is explicitly documented as "likely not pass[ed]"
816 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
817 dll_name
= get_image_name (current_process_handle
,
818 event
->lpImageName
, event
->fUnicode
);
822 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
823 solib_end
= solib_end
->next
;
825 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
827 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
828 host_address_to_string (li
->load_addr
)));
832 windows_free_so (struct so_list
*so
)
834 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
840 /* Handle a DLL unload event.
841 Return 1 if successful, or zero otherwise.
843 This function assumes that this event did not occur during inferior
844 initialization, where their event info may be incomplete (see
845 do_initial_windows_stuff and windows_add_all_dlls for more info
846 on how we handle DLL loading during that phase). */
851 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
854 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
856 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
858 if (li_next
->load_addr
== lpBaseOfDll
)
860 struct so_list
*sodel
= so
->next
;
862 so
->next
= sodel
->next
;
865 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
867 windows_free_so (sodel
);
872 /* We did not find any DLL that was previously loaded at this address,
873 so register a complaint. We do not report an error, because we have
874 observed that this may be happening under some circumstances. For
875 instance, running 32bit applications on x64 Windows causes us to receive
876 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
877 events are apparently caused by the WOW layer, the interface between
878 32bit and 64bit worlds). */
879 complaint (_("dll starting at %s not found."),
880 host_address_to_string (lpBaseOfDll
));
883 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
887 catch_errors (void (*func
) ())
893 CATCH (ex
, RETURN_MASK_ALL
)
895 exception_print (gdb_stderr
, ex
);
900 /* Clear list of loaded DLLs. */
902 windows_clear_solib (void)
904 solib_start
.next
= NULL
;
905 solib_end
= &solib_start
;
909 signal_event_command (const char *args
, int from_tty
)
911 uintptr_t event_id
= 0;
912 char *endargs
= NULL
;
915 error (_("signal-event requires an argument (integer event id)"));
917 event_id
= strtoumax (args
, &endargs
, 10);
919 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
920 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
921 error (_("Failed to convert `%s' to event id"), args
);
923 SetEvent ((HANDLE
) event_id
);
924 CloseHandle ((HANDLE
) event_id
);
927 /* Handle DEBUG_STRING output from child process.
928 Cygwin prepends its messages with a "cygwin:". Interpret this as
929 a Cygwin signal. Otherwise just print the string as a warning. */
931 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
933 gdb::unique_xmalloc_ptr
<char> s
;
936 if (!target_read_string
937 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
939 || !s
|| !*(s
.get ()))
941 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
944 if (!startswith (s
.get (), "cYg"))
947 char *p
= strchr (s
.get (), '\0');
949 if (p
> s
.get () && *--p
== '\n')
951 warning (("%s"), s
.get ());
957 /* Got a cygwin signal marker. A cygwin signal is followed by
958 the signal number itself and then optionally followed by the
959 thread id and address to saved context within the DLL. If
960 these are supplied, then the given thread is assumed to have
961 issued the signal and the context from the thread is assumed
962 to be stored at the given address in the inferior. Tell gdb
963 to treat this like a real signal. */
965 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
966 gdb_signal gotasig
= gdb_signal_from_host (sig
);
968 ourstatus
->value
.sig
= gotasig
;
974 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
975 retval
= strtoul (p
, &p
, 0);
977 retval
= main_thread_id
;
978 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
979 && ReadProcessMemory (current_process_handle
, x
,
981 __COPY_CONTEXT_SIZE
, &n
)
982 && n
== __COPY_CONTEXT_SIZE
)
983 have_saved_context
= 1;
992 display_selector (HANDLE thread
, DWORD sel
)
995 if (GetThreadSelectorEntry (thread
, sel
, &info
))
998 printf_filtered ("0x%03x: ", (unsigned) sel
);
999 if (!info
.HighWord
.Bits
.Pres
)
1001 puts_filtered ("Segment not present\n");
1004 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1005 (info
.HighWord
.Bits
.BaseMid
<< 16)
1007 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1008 if (info
.HighWord
.Bits
.Granularity
)
1009 limit
= (limit
<< 12) | 0xfff;
1010 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1011 if (info
.HighWord
.Bits
.Default_Big
)
1012 puts_filtered(" 32-bit ");
1014 puts_filtered(" 16-bit ");
1015 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1018 puts_filtered ("Data (Read-Only, Exp-up");
1021 puts_filtered ("Data (Read/Write, Exp-up");
1024 puts_filtered ("Unused segment (");
1027 puts_filtered ("Data (Read/Write, Exp-down");
1030 puts_filtered ("Code (Exec-Only, N.Conf");
1033 puts_filtered ("Code (Exec/Read, N.Conf");
1036 puts_filtered ("Code (Exec-Only, Conf");
1039 puts_filtered ("Code (Exec/Read, Conf");
1042 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1044 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1045 puts_filtered(", N.Acc");
1046 puts_filtered (")\n");
1047 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1048 puts_filtered("System selector ");
1049 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1050 if (info
.HighWord
.Bits
.Granularity
)
1051 puts_filtered ("Page granular.\n");
1053 puts_filtered ("Byte granular.\n");
1058 DWORD err
= GetLastError ();
1059 if (err
== ERROR_NOT_SUPPORTED
)
1060 printf_filtered ("Function not supported\n");
1062 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1068 display_selectors (const char * args
, int from_tty
)
1070 if (!current_thread
)
1072 puts_filtered ("Impossible to display selectors now.\n");
1078 puts_filtered ("Selector $cs\n");
1079 display_selector (current_thread
->h
,
1080 current_thread
->context
.SegCs
);
1081 puts_filtered ("Selector $ds\n");
1082 display_selector (current_thread
->h
,
1083 current_thread
->context
.SegDs
);
1084 puts_filtered ("Selector $es\n");
1085 display_selector (current_thread
->h
,
1086 current_thread
->context
.SegEs
);
1087 puts_filtered ("Selector $ss\n");
1088 display_selector (current_thread
->h
,
1089 current_thread
->context
.SegSs
);
1090 puts_filtered ("Selector $fs\n");
1091 display_selector (current_thread
->h
,
1092 current_thread
->context
.SegFs
);
1093 puts_filtered ("Selector $gs\n");
1094 display_selector (current_thread
->h
,
1095 current_thread
->context
.SegGs
);
1100 sel
= parse_and_eval_long (args
);
1101 printf_filtered ("Selector \"%s\"\n",args
);
1102 display_selector (current_thread
->h
, sel
);
1106 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1107 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1108 host_address_to_string (\
1109 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1111 static handle_exception_result
1112 handle_exception (struct target_waitstatus
*ourstatus
)
1114 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1115 DWORD code
= rec
->ExceptionCode
;
1116 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1118 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1120 /* Record the context of the current thread. */
1121 thread_rec (current_event
.dwThreadId
, -1);
1125 case EXCEPTION_ACCESS_VIOLATION
:
1126 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1127 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1130 /* See if the access violation happened within the cygwin DLL
1131 itself. Cygwin uses a kind of exception handling to deal
1132 with passed-in invalid addresses. gdb should not treat
1133 these as real SEGVs since they will be silently handled by
1134 cygwin. A real SEGV will (theoretically) be caught by
1135 cygwin later in the process and will be sent as a
1136 cygwin-specific-signal. So, ignore SEGVs if they show up
1137 within the text segment of the DLL itself. */
1139 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1141 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1142 && addr
< cygwin_load_end
))
1143 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1144 && startswith (fn
, "KERNEL32!IsBad")))
1145 return HANDLE_EXCEPTION_UNHANDLED
;
1149 case STATUS_STACK_OVERFLOW
:
1150 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1151 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1153 case STATUS_FLOAT_DENORMAL_OPERAND
:
1154 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1155 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1157 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1158 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1159 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1161 case STATUS_FLOAT_INEXACT_RESULT
:
1162 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1163 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1165 case STATUS_FLOAT_INVALID_OPERATION
:
1166 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1167 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1169 case STATUS_FLOAT_OVERFLOW
:
1170 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1171 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1173 case STATUS_FLOAT_STACK_CHECK
:
1174 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1175 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1177 case STATUS_FLOAT_UNDERFLOW
:
1178 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1179 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1181 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1182 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1183 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1185 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1186 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1187 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1189 case STATUS_INTEGER_OVERFLOW
:
1190 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1191 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1193 case EXCEPTION_BREAKPOINT
:
1194 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1195 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1198 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1199 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1201 case DBG_CONTROL_BREAK
:
1202 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1203 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1205 case EXCEPTION_SINGLE_STEP
:
1206 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1209 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1210 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1213 case EXCEPTION_PRIV_INSTRUCTION
:
1214 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1217 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1218 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1221 case MS_VC_EXCEPTION
:
1222 if (rec
->NumberParameters
>= 3
1223 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1225 DWORD named_thread_id
;
1226 windows_thread_info
*named_thread
;
1227 CORE_ADDR thread_name_target
;
1229 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1231 thread_name_target
= rec
->ExceptionInformation
[1];
1232 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1234 if (named_thread_id
== (DWORD
) -1)
1235 named_thread_id
= current_event
.dwThreadId
;
1237 named_thread
= thread_rec (named_thread_id
, 0);
1238 if (named_thread
!= NULL
)
1240 int thread_name_len
;
1241 gdb::unique_xmalloc_ptr
<char> thread_name
;
1243 thread_name_len
= target_read_string (thread_name_target
,
1244 &thread_name
, 1025, NULL
);
1245 if (thread_name_len
> 0)
1247 thread_name
.get ()[thread_name_len
- 1] = '\0';
1248 xfree (named_thread
->name
);
1249 named_thread
->name
= thread_name
.release ();
1252 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1253 result
= HANDLE_EXCEPTION_IGNORED
;
1256 /* treat improperly formed exception as unknown */
1259 /* Treat unhandled first chance exceptions specially. */
1260 if (current_event
.u
.Exception
.dwFirstChance
)
1261 return HANDLE_EXCEPTION_UNHANDLED
;
1262 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1263 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1264 host_address_to_string (
1265 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1266 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1270 last_sig
= ourstatus
->value
.sig
;
1274 /* Resume thread specified by ID, or all artificially suspended
1275 threads, if we are continuing execution. KILLED non-zero means we
1276 have killed the inferior, so we should ignore weird errors due to
1277 threads shutting down. */
1279 windows_continue (DWORD continue_status
, int id
, int killed
)
1282 windows_thread_info
*th
;
1285 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1286 (unsigned) current_event
.dwProcessId
,
1287 (unsigned) current_event
.dwThreadId
,
1288 continue_status
== DBG_CONTINUE
?
1289 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1291 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1292 if ((id
== -1 || id
== (int) th
->id
)
1295 if (debug_registers_changed
)
1297 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1298 th
->context
.Dr0
= dr
[0];
1299 th
->context
.Dr1
= dr
[1];
1300 th
->context
.Dr2
= dr
[2];
1301 th
->context
.Dr3
= dr
[3];
1302 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1303 th
->context
.Dr7
= dr
[7];
1305 if (th
->context
.ContextFlags
)
1309 if (GetExitCodeThread (th
->h
, &ec
)
1310 && ec
== STILL_ACTIVE
)
1312 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1317 th
->context
.ContextFlags
= 0;
1319 if (th
->suspended
> 0)
1320 (void) ResumeThread (th
->h
);
1324 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1325 current_event
.dwThreadId
,
1329 error (_("Failed to resume program execution"
1330 " (ContinueDebugEvent failed, error %u)"),
1331 (unsigned int) GetLastError ());
1333 debug_registers_changed
= 0;
1337 /* Called in pathological case where Windows fails to send a
1338 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1340 fake_create_process (void)
1342 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1343 current_event
.dwProcessId
);
1344 if (current_process_handle
!= NULL
)
1345 open_process_used
= 1;
1348 error (_("OpenProcess call failed, GetLastError = %u"),
1349 (unsigned) GetLastError ());
1350 /* We can not debug anything in that case. */
1352 main_thread_id
= current_event
.dwThreadId
;
1353 current_thread
= windows_add_thread (
1354 ptid_build (current_event
.dwProcessId
, 0,
1355 current_event
.dwThreadId
),
1356 current_event
.u
.CreateThread
.hThread
,
1357 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1358 return main_thread_id
;
1362 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1364 windows_thread_info
*th
;
1365 DWORD continue_status
= DBG_CONTINUE
;
1367 /* A specific PTID means `step only this thread id'. */
1368 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1370 /* If we're continuing all threads, it's the current inferior that
1371 should be handled specially. */
1373 ptid
= inferior_ptid
;
1375 if (sig
!= GDB_SIGNAL_0
)
1377 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1379 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1381 else if (sig
== last_sig
)
1382 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1385 /* This code does not seem to work, because
1386 the kernel does probably not consider changes in the ExceptionRecord
1387 structure when passing the exception to the inferior.
1388 Note that this seems possible in the exception handler itself. */
1391 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1392 if (xlate
[i
].us
== sig
)
1394 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1396 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1399 if (continue_status
== DBG_CONTINUE
)
1401 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1405 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1409 last_sig
= GDB_SIGNAL_0
;
1411 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1412 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1414 /* Get context for currently selected thread. */
1415 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1420 /* Single step by setting t bit. */
1421 struct regcache
*regcache
= get_current_regcache ();
1422 struct gdbarch
*gdbarch
= regcache
->arch ();
1423 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1424 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1427 if (th
->context
.ContextFlags
)
1429 if (debug_registers_changed
)
1431 th
->context
.Dr0
= dr
[0];
1432 th
->context
.Dr1
= dr
[1];
1433 th
->context
.Dr2
= dr
[2];
1434 th
->context
.Dr3
= dr
[3];
1435 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1436 th
->context
.Dr7
= dr
[7];
1438 CHECK (SetThreadContext (th
->h
, &th
->context
));
1439 th
->context
.ContextFlags
= 0;
1443 /* Allow continuing with the same signal that interrupted us.
1444 Otherwise complain. */
1447 windows_continue (continue_status
, -1, 0);
1449 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1452 /* Ctrl-C handler used when the inferior is not run in the same console. The
1453 handler is in charge of interrupting the inferior using DebugBreakProcess.
1454 Note that this function is not available prior to Windows XP. In this case
1455 we emit a warning. */
1457 ctrl_c_handler (DWORD event_type
)
1459 const int attach_flag
= current_inferior ()->attach_flag
;
1461 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1462 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1465 /* If the inferior and the debugger share the same console, do nothing as
1466 the inferior has also received the Ctrl-C event. */
1467 if (!new_console
&& !attach_flag
)
1470 if (!DebugBreakProcess (current_process_handle
))
1471 warning (_("Could not interrupt program. "
1472 "Press Ctrl-c in the program console."));
1474 /* Return true to tell that Ctrl-C has been handled. */
1478 /* Get the next event from the child. Returns a non-zero thread id if the event
1479 requires handling by WFI (or whatever). */
1481 get_windows_debug_event (struct target_ops
*ops
,
1482 int pid
, struct target_waitstatus
*ourstatus
)
1485 DWORD continue_status
, event_code
;
1486 windows_thread_info
*th
;
1487 static windows_thread_info dummy_thread_info
;
1488 DWORD thread_id
= 0;
1490 last_sig
= GDB_SIGNAL_0
;
1492 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1496 continue_status
= DBG_CONTINUE
;
1498 event_code
= current_event
.dwDebugEventCode
;
1499 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1501 have_saved_context
= 0;
1505 case CREATE_THREAD_DEBUG_EVENT
:
1506 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1507 (unsigned) current_event
.dwProcessId
,
1508 (unsigned) current_event
.dwThreadId
,
1509 "CREATE_THREAD_DEBUG_EVENT"));
1510 if (saw_create
!= 1)
1512 struct inferior
*inf
;
1513 inf
= find_inferior_pid (current_event
.dwProcessId
);
1514 if (!saw_create
&& inf
->attach_flag
)
1516 /* Kludge around a Windows bug where first event is a create
1517 thread event. Caused when attached process does not have
1519 thread_id
= fake_create_process ();
1525 /* Record the existence of this thread. */
1526 thread_id
= current_event
.dwThreadId
;
1527 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1528 current_event
.dwThreadId
),
1529 current_event
.u
.CreateThread
.hThread
,
1530 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1534 case EXIT_THREAD_DEBUG_EVENT
:
1535 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1536 (unsigned) current_event
.dwProcessId
,
1537 (unsigned) current_event
.dwThreadId
,
1538 "EXIT_THREAD_DEBUG_EVENT"));
1540 if (current_event
.dwThreadId
!= main_thread_id
)
1542 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1543 current_event
.dwThreadId
),
1544 current_event
.u
.ExitThread
.dwExitCode
);
1545 th
= &dummy_thread_info
;
1549 case CREATE_PROCESS_DEBUG_EVENT
:
1550 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1551 (unsigned) current_event
.dwProcessId
,
1552 (unsigned) current_event
.dwThreadId
,
1553 "CREATE_PROCESS_DEBUG_EVENT"));
1554 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1555 if (++saw_create
!= 1)
1558 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1560 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1563 main_thread_id
= current_event
.dwThreadId
;
1564 /* Add the main thread. */
1565 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1566 current_event
.dwThreadId
),
1567 current_event
.u
.CreateProcessInfo
.hThread
,
1568 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1569 thread_id
= current_event
.dwThreadId
;
1572 case EXIT_PROCESS_DEBUG_EVENT
:
1573 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1574 (unsigned) current_event
.dwProcessId
,
1575 (unsigned) current_event
.dwThreadId
,
1576 "EXIT_PROCESS_DEBUG_EVENT"));
1577 if (!windows_initialization_done
)
1579 target_terminal::ours ();
1580 target_mourn_inferior (inferior_ptid
);
1581 error (_("During startup program exited with code 0x%x."),
1582 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1584 else if (saw_create
== 1)
1586 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1587 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1588 thread_id
= main_thread_id
;
1592 case LOAD_DLL_DEBUG_EVENT
:
1593 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1594 (unsigned) current_event
.dwProcessId
,
1595 (unsigned) current_event
.dwThreadId
,
1596 "LOAD_DLL_DEBUG_EVENT"));
1597 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1598 if (saw_create
!= 1 || ! windows_initialization_done
)
1600 catch_errors (handle_load_dll
);
1601 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1602 ourstatus
->value
.integer
= 0;
1603 thread_id
= main_thread_id
;
1606 case UNLOAD_DLL_DEBUG_EVENT
:
1607 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1608 (unsigned) current_event
.dwProcessId
,
1609 (unsigned) current_event
.dwThreadId
,
1610 "UNLOAD_DLL_DEBUG_EVENT"));
1611 if (saw_create
!= 1 || ! windows_initialization_done
)
1613 catch_errors (handle_unload_dll
);
1614 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1615 ourstatus
->value
.integer
= 0;
1616 thread_id
= main_thread_id
;
1619 case EXCEPTION_DEBUG_EVENT
:
1620 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1621 (unsigned) current_event
.dwProcessId
,
1622 (unsigned) current_event
.dwThreadId
,
1623 "EXCEPTION_DEBUG_EVENT"));
1624 if (saw_create
!= 1)
1626 switch (handle_exception (ourstatus
))
1628 case HANDLE_EXCEPTION_UNHANDLED
:
1630 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1632 case HANDLE_EXCEPTION_HANDLED
:
1633 thread_id
= current_event
.dwThreadId
;
1635 case HANDLE_EXCEPTION_IGNORED
:
1636 continue_status
= DBG_CONTINUE
;
1641 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1642 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1643 (unsigned) current_event
.dwProcessId
,
1644 (unsigned) current_event
.dwThreadId
,
1645 "OUTPUT_DEBUG_STRING_EVENT"));
1646 if (saw_create
!= 1)
1648 thread_id
= handle_output_debug_string (ourstatus
);
1652 if (saw_create
!= 1)
1654 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1655 (unsigned) current_event
.dwProcessId
,
1656 (unsigned) current_event
.dwThreadId
);
1657 printf_unfiltered (" unknown event code %u\n",
1658 (unsigned) current_event
.dwDebugEventCode
);
1662 if (!thread_id
|| saw_create
!= 1)
1664 CHECK (windows_continue (continue_status
, -1, 0));
1668 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1670 current_thread
= th
;
1671 if (!current_thread
)
1672 current_thread
= thread_rec (thread_id
, TRUE
);
1679 /* Wait for interesting events to occur in the target process. */
1681 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1686 target_terminal::ours ();
1688 /* We loop when we get a non-standard exception rather than return
1689 with a SPURIOUS because resume can try and step or modify things,
1690 which needs a current_thread->h. But some of these exceptions mark
1691 the birth or death of threads, which mean that the current thread
1692 isn't necessarily what you think it is. */
1698 /* If the user presses Ctrl-c while the debugger is waiting
1699 for an event, he expects the debugger to interrupt his program
1700 and to get the prompt back. There are two possible situations:
1702 - The debugger and the program do not share the console, in
1703 which case the Ctrl-c event only reached the debugger.
1704 In that case, the ctrl_c handler will take care of interrupting
1705 the inferior. Note that this case is working starting with
1706 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1709 - The debugger and the program share the same console, in which
1710 case both debugger and inferior will receive the Ctrl-c event.
1711 In that case the ctrl_c handler will ignore the event, as the
1712 Ctrl-c event generated inside the inferior will trigger the
1713 expected debug event.
1715 FIXME: brobecker/2008-05-20: If the inferior receives the
1716 signal first and the delay until GDB receives that signal
1717 is sufficiently long, GDB can sometimes receive the SIGINT
1718 after we have unblocked the CTRL+C handler. This would
1719 lead to the debugger stopping prematurely while handling
1720 the new-thread event that comes with the handling of the SIGINT
1721 inside the inferior, and then stop again immediately when
1722 the user tries to resume the execution in the inferior.
1723 This is a classic race that we should try to fix one day. */
1724 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1725 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1726 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1729 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1734 if (deprecated_ui_loop_hook
!= NULL
)
1735 detach
= deprecated_ui_loop_hook (0);
1743 /* Iterate over all DLLs currently mapped by our inferior, and
1744 add them to our list of solibs. */
1747 windows_add_all_dlls (void)
1750 HMODULE dummy_hmodule
;
1755 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1756 sizeof (HMODULE
), &cb_needed
) == 0)
1762 hmodules
= (HMODULE
*) alloca (cb_needed
);
1763 if (EnumProcessModules (current_process_handle
, hmodules
,
1764 cb_needed
, &cb_needed
) == 0)
1767 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1771 wchar_t dll_name
[__PMAX
];
1774 char dll_name
[__PMAX
];
1777 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1778 &mi
, sizeof (mi
)) == 0)
1780 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1781 dll_name
, sizeof (dll_name
)) == 0)
1784 wcstombs (name
, dll_name
, __PMAX
);
1789 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1790 solib_end
= solib_end
->next
;
1795 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1798 struct inferior
*inf
;
1799 struct thread_info
*tp
;
1801 last_sig
= GDB_SIGNAL_0
;
1803 exception_count
= 0;
1804 open_process_used
= 0;
1805 debug_registers_changed
= 0;
1806 debug_registers_used
= 0;
1807 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1810 cygwin_load_start
= cygwin_load_end
= 0;
1812 current_event
.dwProcessId
= pid
;
1813 memset (¤t_event
, 0, sizeof (current_event
));
1814 if (!target_is_pushed (ops
))
1816 disable_breakpoints_in_shlibs ();
1817 windows_clear_solib ();
1818 clear_proceed_status (0);
1819 init_wait_for_inferior ();
1821 inf
= current_inferior ();
1822 inferior_appeared (inf
, pid
);
1823 inf
->attach_flag
= attaching
;
1825 /* Make the new process the current inferior, so terminal handling
1826 can rely on it. When attaching, we don't know about any thread
1827 id here, but that's OK --- nothing should be referencing the
1828 current thread until we report an event out of windows_wait. */
1829 inferior_ptid
= pid_to_ptid (pid
);
1831 target_terminal::init ();
1832 target_terminal::inferior ();
1834 windows_initialization_done
= 0;
1838 struct target_waitstatus status
;
1840 ops
->wait (minus_one_ptid
, &status
, 0);
1842 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1844 if (status
.kind
!= TARGET_WAITKIND_LOADED
1845 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1848 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1851 /* Now that the inferior has been started and all DLLs have been mapped,
1852 we can iterate over all DLLs and load them in.
1854 We avoid doing it any earlier because, on certain versions of Windows,
1855 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1856 we have seen on Windows 8.1 that the ntdll.dll load event does not
1857 include the DLL name, preventing us from creating an associated SO.
1858 A possible explanation is that ntdll.dll might be mapped before
1859 the SO info gets created by the Windows system -- ntdll.dll is
1860 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1861 do not seem to suffer from that problem.
1863 Rather than try to work around this sort of issue, it is much
1864 simpler to just ignore DLL load/unload events during the startup
1865 phase, and then process them all in one batch now. */
1866 windows_add_all_dlls ();
1868 windows_initialization_done
= 1;
1872 /* Try to set or remove a user privilege to the current process. Return -1
1873 if that fails, the previous setting of that privilege otherwise.
1875 This code is copied from the Cygwin source code and rearranged to allow
1876 dynamically loading of the needed symbols from advapi32 which is only
1877 available on NT/2K/XP. */
1879 set_process_privilege (const char *privilege
, BOOL enable
)
1881 HANDLE token_hdl
= NULL
;
1883 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1887 if (!OpenProcessToken (GetCurrentProcess (),
1888 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1892 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1895 new_priv
.PrivilegeCount
= 1;
1896 new_priv
.Privileges
[0].Luid
= restore_priv
;
1897 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1899 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1900 sizeof orig_priv
, &orig_priv
, &size
))
1903 /* Disabled, otherwise every `attach' in an unprivileged user session
1904 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1905 windows_attach(). */
1906 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1907 be enabled. GetLastError () returns an correct error code, though. */
1908 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1912 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1916 CloseHandle (token_hdl
);
1921 /* Attach to process PID, then initialize for debugging it. */
1924 windows_nat_target::attach (const char *args
, int from_tty
)
1929 pid
= parse_pid_to_attach (args
);
1931 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1933 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1934 printf_unfiltered ("This can cause attach to "
1935 "fail on Windows NT/2K/XP\n");
1938 windows_init_thread_list ();
1939 ok
= DebugActiveProcess (pid
);
1945 /* Try fall back to Cygwin pid. */
1946 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1949 ok
= DebugActiveProcess (pid
);
1954 error (_("Can't attach to process."));
1956 DebugSetProcessKillOnExit (FALSE
);
1960 char *exec_file
= (char *) get_exec_file (0);
1963 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1964 target_pid_to_str (pid_to_ptid (pid
)));
1966 printf_unfiltered ("Attaching to %s\n",
1967 target_pid_to_str (pid_to_ptid (pid
)));
1969 gdb_flush (gdb_stdout
);
1972 do_initial_windows_stuff (this, pid
, 1);
1973 target_terminal::ours ();
1977 windows_nat_target::detach (inferior
*inf
, int from_tty
)
1981 ptid_t ptid
= minus_one_ptid
;
1982 resume (ptid
, 0, GDB_SIGNAL_0
);
1984 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1986 error (_("Can't detach process %u (error %u)"),
1987 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1990 DebugSetProcessKillOnExit (FALSE
);
1992 if (detached
&& from_tty
)
1994 const char *exec_file
= get_exec_file (0);
1997 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1998 (unsigned) current_event
.dwProcessId
);
1999 gdb_flush (gdb_stdout
);
2002 x86_cleanup_dregs ();
2003 inferior_ptid
= null_ptid
;
2004 detach_inferior (current_event
.dwProcessId
);
2006 maybe_unpush_target ();
2009 /* Try to determine the executable filename.
2011 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2013 Upon success, the filename is stored inside EXE_NAME_RET, and
2014 this function returns nonzero.
2016 Otherwise, this function returns zero and the contents of
2017 EXE_NAME_RET is undefined. */
2020 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2027 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2028 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2031 /* We know the executable is always first in the list of modules,
2032 which we just fetched. So no need to fetch more. */
2036 /* Cygwin prefers that the path be in /x/y/z format, so extract
2037 the filename into a temporary buffer first, and then convert it
2038 to POSIX format into the destination buffer. */
2039 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2041 len
= GetModuleFileNameEx (current_process_handle
,
2042 dh_buf
, pathbuf
, exe_name_max_len
);
2044 error (_("Error getting executable filename: %u."),
2045 (unsigned) GetLastError ());
2046 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2047 exe_name_max_len
) < 0)
2048 error (_("Error converting executable filename to POSIX: %d."), errno
);
2051 len
= GetModuleFileNameEx (current_process_handle
,
2052 dh_buf
, exe_name_ret
, exe_name_max_len
);
2054 error (_("Error getting executable filename: %u."),
2055 (unsigned) GetLastError ());
2058 return 1; /* success */
2061 /* The pid_to_exec_file target_ops method for this platform. */
2064 windows_nat_target::pid_to_exec_file (int pid
)
2066 static char path
[__PMAX
];
2068 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2070 char procexe
[sizeof ("/proc/4294967295/exe")];
2072 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2073 nchars
= readlink (procexe
, path
, sizeof(path
));
2074 if (nchars
> 0 && nchars
< sizeof (path
))
2076 path
[nchars
] = '\0'; /* Got it */
2081 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2082 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2083 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2089 /* Print status information about what we're accessing. */
2092 windows_nat_target::files_info ()
2094 struct inferior
*inf
= current_inferior ();
2096 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2097 inf
->attach_flag
? "attached" : "child",
2098 target_pid_to_str (inferior_ptid
));
2101 /* Modify CreateProcess parameters for use of a new separate console.
2103 *FLAGS: DWORD parameter for general process creation flags.
2104 *SI: STARTUPINFO structure, for which the console window size and
2105 console buffer size is filled in if GDB is running in a console.
2106 to create the new console.
2107 The size of the used font is not available on all versions of
2108 Windows OS. Furthermore, the current font might not be the default
2109 font, but this is still better than before.
2110 If the windows and buffer sizes are computed,
2111 SI->DWFLAGS is changed so that this information is used
2112 by CreateProcess function. */
2115 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2117 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2118 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2120 if (hconsole
!= INVALID_HANDLE_VALUE
)
2122 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2124 CONSOLE_FONT_INFO cfi
;
2126 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2127 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2128 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2129 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2130 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2132 si
->dwXSize
*= font_size
.X
;
2136 si
->dwYSize
*= font_size
.Y
;
2139 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2140 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2141 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2143 *flags
|= CREATE_NEW_CONSOLE
;
2147 /* Function called by qsort to sort environment strings. */
2150 envvar_cmp (const void *a
, const void *b
)
2152 const char **p
= (const char **) a
;
2153 const char **q
= (const char **) b
;
2154 return strcasecmp (*p
, *q
);
2160 clear_win32_environment (char **env
)
2164 wchar_t *copy
= NULL
, *equalpos
;
2166 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2168 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2169 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2170 mbstowcs (copy
, env
[i
], len
);
2171 equalpos
= wcschr (copy
, L
'=');
2174 SetEnvironmentVariableW (copy
, NULL
);
2182 /* Redirection of inferior I/O streams for native MS-Windows programs.
2183 Unlike on Unix, where this is handled by invoking the inferior via
2184 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2186 The official documentation of the cmd.exe redirection features is here:
2188 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2190 (That page talks about Windows XP, but there's no newer
2191 documentation, so we assume later versions of cmd.exe didn't change
2194 Caveat: the documentation on that page seems to include a few lies.
2195 For example, it describes strange constructs 1<&2 and 2<&1, which
2196 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2197 think the cmd.exe parser of the redirection symbols simply doesn't
2198 care about the < vs > distinction in these cases. Therefore, the
2199 supported features are explicitly documented below.
2201 The emulation below aims at supporting all the valid use cases
2202 supported by cmd.exe, which include:
2204 < FILE redirect standard input from FILE
2205 0< FILE redirect standard input from FILE
2206 <&N redirect standard input from file descriptor N
2207 0<&N redirect standard input from file descriptor N
2208 > FILE redirect standard output to FILE
2209 >> FILE append standard output to FILE
2210 1>> FILE append standard output to FILE
2211 >&N redirect standard output to file descriptor N
2212 1>&N redirect standard output to file descriptor N
2213 >>&N append standard output to file descriptor N
2214 1>>&N append standard output to file descriptor N
2215 2> FILE redirect standard error to FILE
2216 2>> FILE append standard error to FILE
2217 2>&N redirect standard error to file descriptor N
2218 2>>&N append standard error to file descriptor N
2220 Note that using N > 2 in the above construct is supported, but
2221 requires that the corresponding file descriptor be open by some
2222 means elsewhere or outside GDB. Also note that using ">&0" or
2223 "<&2" will generally fail, because the file descriptor redirected
2224 from is normally open in an incompatible mode (e.g., FD 0 is open
2225 for reading only). IOW, use of such tricks is not recommended;
2226 you are on your own.
2228 We do NOT support redirection of file descriptors above 2, as in
2229 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2230 that needs special handling in the startup code that MinGW
2231 doesn't have). Pipes are also not supported.
2233 As for invalid use cases, where the redirection contains some
2234 error, the emulation below will detect that and produce some
2235 error and/or failure. But the behavior in those cases is not
2236 bug-for-bug compatible with what cmd.exe does in those cases.
2237 That's because what cmd.exe does then is not well defined, and
2238 seems to be a side effect of the cmd.exe parsing of the command
2239 line more than anything else. For example, try redirecting to an
2240 invalid file name, as in "> foo:bar".
2242 There are also minor syntactic deviations from what cmd.exe does
2243 in some corner cases. For example, it doesn't support the likes
2244 of "> &foo" to mean redirect to file named literally "&foo"; we
2245 do support that here, because that, too, sounds like some issue
2246 with the cmd.exe parser. Another nicety is that we support
2247 redirection targets that use file names with forward slashes,
2248 something cmd.exe doesn't -- this comes in handy since GDB
2249 file-name completion can be used when typing the command line for
2252 /* Support routines for redirecting standard handles of the inferior. */
2254 /* Parse a single redirection spec, open/duplicate the specified
2255 file/fd, and assign the appropriate value to one of the 3 standard
2256 file descriptors. */
2258 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2260 int *fd
, ref_fd
= -2;
2262 const char *fname
= redir_string
+ 1;
2263 int rc
= *redir_string
;
2278 fd
= (rc
== '2') ? err
: out
;
2279 mode
= O_WRONLY
| O_CREAT
;
2292 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2294 /* A reference to a file descriptor. */
2296 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2297 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2299 /* Don't allow redirection when open modes are incompatible. */
2300 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2301 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2308 else if (ref_fd
== 1)
2310 else if (ref_fd
== 2)
2320 fname
++; /* skip the separator space */
2321 /* If the descriptor is already open, close it. This allows
2322 multiple specs of redirections for the same stream, which is
2323 somewhat nonsensical, but still valid and supported by cmd.exe.
2324 (But cmd.exe only opens a single file in this case, the one
2325 specified by the last redirection spec on the command line.) */
2330 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2334 else if (ref_fd
== -1)
2335 *fd
= -1; /* reset to default destination */
2338 *fd
= _dup (ref_fd
);
2342 /* _open just sets a flag for O_APPEND, which won't be passed to the
2343 inferior, so we need to actually move the file pointer. */
2344 if ((mode
& O_APPEND
) != 0)
2345 _lseek (*fd
, 0L, SEEK_END
);
2349 /* Canonicalize a single redirection spec and set up the corresponding
2350 file descriptor as specified. */
2352 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2354 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2356 const char *start
= s
;
2359 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2360 if ((*start
== '>' || *start
== '1' || *start
== '2')
2364 if (*s
== '>' && *start
!= '>')
2367 else if (*start
== '0' && *s
== '<')
2369 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2372 while (isspace (*s
)) /* skip whitespace before file name */
2374 *d
++ = ' '; /* separate file name with a single space */
2377 /* Copy the file name. */
2380 /* Remove quoting characters from the file name in buf[]. */
2381 if (*s
== '"') /* could support '..' quoting here */
2385 else if (*s
== quote
)
2393 else if (*s
== '\\')
2395 if (s
[1] == '"') /* could support '..' here */
2399 else if (isspace (*s
) && !quote
)
2403 if (d
- buf
>= sizeof (buf
) - 1)
2405 errno
= ENAMETOOLONG
;
2411 /* Windows doesn't allow redirection characters in file names, so we
2412 can bail out early if they use them, or if there's no target file
2413 name after the redirection symbol. */
2414 if (d
[-1] == '>' || d
[-1] == '<')
2419 if (redir_open (buf
, inp
, out
, err
) == 0)
2424 /* Parse the command line for redirection specs and prepare the file
2425 descriptors for the 3 standard streams accordingly. */
2427 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2428 int *inp
, int *out
, int *err
)
2430 const char *s
= cmd_orig
;
2433 bool retval
= false;
2435 while (isspace (*s
))
2440 if (*s
== '"') /* could also support '..' quoting here */
2444 else if (*s
== quote
)
2447 else if (*s
== '\\')
2449 if (s
[1] == '"') /* escaped quote char */
2454 /* Process a single redirection candidate. */
2455 if (*s
== '<' || *s
== '>'
2456 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2457 || (*s
== '0' && s
[1] == '<'))
2459 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2473 #endif /* !__CYGWIN__ */
2475 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2476 EXEC_FILE is the file to run.
2477 ALLARGS is a string containing the arguments to the program.
2478 ENV is the environment vector to pass. Errors reported with error(). */
2481 windows_nat_target::create_inferior (const char *exec_file
,
2482 const std::string
&origallargs
,
2483 char **in_env
, int from_tty
)
2487 cygwin_buf_t real_path
[__PMAX
];
2488 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2489 cygwin_buf_t infcwd
[__PMAX
];
2491 cygwin_buf_t
*toexec
;
2492 cygwin_buf_t
*cygallargs
;
2494 char **old_env
= NULL
;
2498 int ostdin
, ostdout
, ostderr
;
2499 #else /* !__CYGWIN__ */
2500 char real_path
[__PMAX
];
2501 char shell
[__PMAX
]; /* Path to shell */
2503 char *args
, *allargs_copy
;
2504 size_t args_len
, allargs_len
;
2505 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2506 HANDLE tty
= INVALID_HANDLE_VALUE
;
2507 HANDLE inf_stdin
= INVALID_HANDLE_VALUE
;
2508 HANDLE inf_stdout
= INVALID_HANDLE_VALUE
;
2509 HANDLE inf_stderr
= INVALID_HANDLE_VALUE
;
2510 bool redirected
= false;
2517 #endif /* !__CYGWIN__ */
2518 const char *allargs
= origallargs
.c_str ();
2519 PROCESS_INFORMATION pi
;
2522 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2525 error (_("No executable specified, use `target exec'."));
2527 const char *inferior_cwd
= get_inferior_cwd ();
2528 std::string expanded_infcwd
;
2529 if (inferior_cwd
!= NULL
)
2531 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2532 /* Mirror slashes on inferior's cwd. */
2533 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2535 inferior_cwd
= expanded_infcwd
.c_str ();
2538 memset (&si
, 0, sizeof (si
));
2539 si
.cb
= sizeof (si
);
2542 flags
|= CREATE_NEW_PROCESS_GROUP
;
2545 windows_set_console_info (&si
, &flags
);
2550 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2551 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2552 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2553 error (_("Error starting executable: %d"), errno
);
2556 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2557 if (len
== (size_t) -1)
2558 error (_("Error starting executable: %d"), errno
);
2559 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2560 mbstowcs (cygallargs
, allargs
, len
);
2561 #else /* !__USEWIDE */
2562 cygallargs
= allargs
;
2567 sh
= getenv ("SHELL");
2570 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2571 error (_("Error starting executable via shell: %d"), errno
);
2573 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2574 + mbstowcs (NULL
, allargs
, 0) + 2;
2575 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2576 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2577 #else /* !__USEWIDE */
2578 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2579 + strlen (allargs
) + 2);
2580 cygallargs
= (char *) alloca (len
);
2581 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2582 #endif /* __USEWIDE */
2584 flags
|= DEBUG_PROCESS
;
2587 if (inferior_cwd
!= NULL
2588 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2589 infcwd
, strlen (inferior_cwd
)) < 0)
2590 error (_("Error converting inferior cwd: %d"), errno
);
2593 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2594 * sizeof (wchar_t));
2595 wcscpy (args
, toexec
);
2596 wcscat (args
, L
" ");
2597 wcscat (args
, cygallargs
);
2598 #else /* !__USEWIDE */
2599 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2600 strcpy (args
, toexec
);
2602 strcat (args
, cygallargs
);
2603 #endif /* !__USEWIDE */
2605 #ifdef CW_CVT_ENV_TO_WINENV
2606 /* First try to create a direct Win32 copy of the POSIX environment. */
2607 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2608 if (w32_env
!= (PWCHAR
) -1)
2609 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2611 /* If that fails, fall back to old method tweaking GDB's environment. */
2612 #endif /* CW_CVT_ENV_TO_WINENV */
2614 /* Reset all Win32 environment variables to avoid leftover on next run. */
2615 clear_win32_environment (environ
);
2616 /* Prepare the environment vars for CreateProcess. */
2619 cygwin_internal (CW_SYNC_WINENV
);
2623 if (!inferior_io_terminal
)
2624 tty
= ostdin
= ostdout
= ostderr
= -1;
2627 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2630 print_sys_errmsg (inferior_io_terminal
, errno
);
2631 ostdin
= ostdout
= ostderr
= -1;
2644 windows_init_thread_list ();
2645 ret
= CreateProcess (0,
2646 args
, /* command line */
2647 NULL
, /* Security */
2649 TRUE
, /* inherit handles */
2650 flags
, /* start flags */
2651 w32_env
, /* environment */
2652 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2657 /* Just free the Win32 environment, if it could be created. */
2661 /* Reset all environment variables to avoid leftover on next run. */
2662 clear_win32_environment (in_env
);
2663 /* Restore normal GDB environment variables. */
2665 cygwin_internal (CW_SYNC_WINENV
);
2678 #else /* !__CYGWIN__ */
2679 allargs_len
= strlen (allargs
);
2680 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2681 if (strpbrk (allargs_copy
, "<>") != NULL
)
2686 redirect_inferior_handles (allargs
, allargs_copy
,
2687 &fd_inp
, &fd_out
, &fd_err
);
2689 warning (_("Error in redirection: %s."), strerror (errno
));
2692 allargs_len
= strlen (allargs_copy
);
2694 /* If not all the standard streams are redirected by the command
2695 line, use inferior_io_terminal for those which aren't. */
2696 if (inferior_io_terminal
2697 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2699 SECURITY_ATTRIBUTES sa
;
2700 sa
.nLength
= sizeof(sa
);
2701 sa
.lpSecurityDescriptor
= 0;
2702 sa
.bInheritHandle
= TRUE
;
2703 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2704 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2705 if (tty
== INVALID_HANDLE_VALUE
)
2706 warning (_("Warning: Failed to open TTY %s, error %#x."),
2707 inferior_io_terminal
, (unsigned) GetLastError ());
2709 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2712 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2713 else if (tty
!= INVALID_HANDLE_VALUE
)
2716 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2718 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2719 else if (tty
!= INVALID_HANDLE_VALUE
)
2720 si
.hStdOutput
= tty
;
2722 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2724 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2725 else if (tty
!= INVALID_HANDLE_VALUE
)
2728 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2729 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2733 /* Build the command line, a space-separated list of tokens where
2734 the first token is the name of the module to be executed.
2735 To avoid ambiguities introduced by spaces in the module name,
2737 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2738 args
= (char *) alloca (args_len
);
2739 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2741 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2743 /* CreateProcess takes the environment list as a null terminated set of
2744 strings (i.e. two nulls terminate the list). */
2746 /* Get total size for env strings. */
2747 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2748 envlen
+= strlen (in_env
[i
]) + 1;
2750 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2751 env
= (char **) alloca (envsize
);
2752 memcpy (env
, in_env
, envsize
);
2753 /* Windows programs expect the environment block to be sorted. */
2754 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2756 w32env
= (char *) alloca (envlen
+ 1);
2758 /* Copy env strings into new buffer. */
2759 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2761 strcpy (temp
, env
[i
]);
2762 temp
+= strlen (temp
) + 1;
2765 /* Final nil string to terminate new env. */
2768 windows_init_thread_list ();
2769 ret
= CreateProcessA (0,
2770 args
, /* command line */
2771 NULL
, /* Security */
2773 TRUE
, /* inherit handles */
2774 flags
, /* start flags */
2775 w32env
, /* environment */
2776 inferior_cwd
, /* current directory */
2779 if (tty
!= INVALID_HANDLE_VALUE
)
2787 #endif /* !__CYGWIN__ */
2790 error (_("Error creating process %s, (error %u)."),
2791 exec_file
, (unsigned) GetLastError ());
2793 CloseHandle (pi
.hThread
);
2794 CloseHandle (pi
.hProcess
);
2796 if (useshell
&& shell
[0] != '\0')
2801 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2803 /* windows_continue (DBG_CONTINUE, -1, 0); */
2807 windows_nat_target::mourn_inferior ()
2809 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2810 x86_cleanup_dregs();
2811 if (open_process_used
)
2813 CHECK (CloseHandle (current_process_handle
));
2814 open_process_used
= 0;
2816 inf_child_target::mourn_inferior ();
2819 /* Send a SIGINT to the process group. This acts just like the user typed a
2820 ^C on the controlling terminal. */
2823 windows_nat_target::interrupt ()
2825 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2826 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2827 registers_changed (); /* refresh register state */
2830 /* Helper for windows_xfer_partial that handles memory transfers.
2831 Arguments are like target_xfer_partial. */
2833 static enum target_xfer_status
2834 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2835 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2839 DWORD lasterror
= 0;
2841 if (writebuf
!= NULL
)
2843 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2844 pulongest (len
), core_addr_to_string (memaddr
)));
2845 success
= WriteProcessMemory (current_process_handle
,
2846 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2849 lasterror
= GetLastError ();
2850 FlushInstructionCache (current_process_handle
,
2851 (LPCVOID
) (uintptr_t) memaddr
, len
);
2855 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2856 pulongest (len
), core_addr_to_string (memaddr
)));
2857 success
= ReadProcessMemory (current_process_handle
,
2858 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2861 lasterror
= GetLastError ();
2863 *xfered_len
= (ULONGEST
) done
;
2864 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2865 return TARGET_XFER_OK
;
2867 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2871 windows_nat_target::kill ()
2873 CHECK (TerminateProcess (current_process_handle
, 0));
2877 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2879 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2881 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2885 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2889 windows_nat_target::close ()
2891 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2892 ptid_get_pid (inferior_ptid
)));
2895 /* Convert pid to printable format. */
2897 windows_nat_target::pid_to_str (ptid_t ptid
)
2899 static char buf
[80];
2901 if (ptid_get_tid (ptid
) != 0)
2903 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2904 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2908 return normal_pid_to_str (ptid
);
2911 static enum target_xfer_status
2912 windows_xfer_shared_libraries (struct target_ops
*ops
,
2913 enum target_object object
, const char *annex
,
2914 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2915 ULONGEST offset
, ULONGEST len
,
2916 ULONGEST
*xfered_len
)
2918 struct obstack obstack
;
2924 return TARGET_XFER_E_IO
;
2926 obstack_init (&obstack
);
2927 obstack_grow_str (&obstack
, "<library-list>\n");
2928 for (so
= solib_start
.next
; so
; so
= so
->next
)
2930 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2932 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2933 (uintptr_t) li
->load_addr
,
2934 target_gdbarch (), &obstack
);
2936 obstack_grow_str0 (&obstack
, "</library-list>\n");
2938 buf
= (const char *) obstack_finish (&obstack
);
2939 len_avail
= strlen (buf
);
2940 if (offset
>= len_avail
)
2944 if (len
> len_avail
- offset
)
2945 len
= len_avail
- offset
;
2946 memcpy (readbuf
, buf
+ offset
, len
);
2949 obstack_free (&obstack
, NULL
);
2950 *xfered_len
= (ULONGEST
) len
;
2951 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2954 enum target_xfer_status
2955 windows_nat_target::xfer_partial (enum target_object object
,
2956 const char *annex
, gdb_byte
*readbuf
,
2957 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2958 ULONGEST
*xfered_len
)
2962 case TARGET_OBJECT_MEMORY
:
2963 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2965 case TARGET_OBJECT_LIBRARIES
:
2966 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2967 writebuf
, offset
, len
, xfered_len
);
2970 return beneath
->xfer_partial (object
, annex
,
2971 readbuf
, writebuf
, offset
, len
,
2976 /* Provide thread local base, i.e. Thread Information Block address.
2977 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2980 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2982 windows_thread_info
*th
;
2984 th
= thread_rec (ptid_get_tid (ptid
), 0);
2989 *addr
= th
->thread_local_base
;
2995 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2997 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
3000 /* Implementation of the to_thread_name method. */
3003 windows_nat_target::thread_name (struct thread_info
*thr
)
3005 return thread_rec (ptid_get_tid (thr
->ptid
), 0)->name
;
3010 _initialize_windows_nat (void)
3012 x86_dr_low
.set_control
= cygwin_set_dr7
;
3013 x86_dr_low
.set_addr
= cygwin_set_dr
;
3014 x86_dr_low
.get_addr
= cygwin_get_dr
;
3015 x86_dr_low
.get_status
= cygwin_get_dr6
;
3016 x86_dr_low
.get_control
= cygwin_get_dr7
;
3018 /* x86_dr_low.debug_register_length field is set by
3019 calling x86_set_debug_register_length function
3020 in processor windows specific native file. */
3022 add_inf_child_target (&the_windows_nat_target
);
3025 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3028 add_com ("signal-event", class_run
, signal_event_command
, _("\
3029 Signal a crashed process with event ID, to allow its debugging.\n\
3030 This command is needed in support of setting up GDB as JIT debugger on \
3031 MS-Windows. The command should be invoked from the GDB command line using \
3032 the '-ex' command-line option. The ID of the event that blocks the \
3033 crashed process will be supplied by the Windows JIT debugging mechanism."));
3036 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3037 Set use of shell to start subprocess."), _("\
3038 Show use of shell to start subprocess."), NULL
,
3040 NULL
, /* FIXME: i18n: */
3041 &setlist
, &showlist
);
3043 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3044 &cygwin_exceptions
, _("\
3045 Break when an exception is detected in the Cygwin DLL itself."), _("\
3046 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3048 NULL
, /* FIXME: i18n: */
3049 &setlist
, &showlist
);
3052 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3053 Set creation of new console when creating child process."), _("\
3054 Show creation of new console when creating child process."), NULL
,
3056 NULL
, /* FIXME: i18n: */
3057 &setlist
, &showlist
);
3059 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3060 Set creation of new group when creating child process."), _("\
3061 Show creation of new group when creating child process."), NULL
,
3063 NULL
, /* FIXME: i18n: */
3064 &setlist
, &showlist
);
3066 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3067 Set whether to display execution in child process."), _("\
3068 Show whether to display execution in child process."), NULL
,
3070 NULL
, /* FIXME: i18n: */
3071 &setlist
, &showlist
);
3073 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3074 Set whether to display kernel events in child process."), _("\
3075 Show whether to display kernel events in child process."), NULL
,
3077 NULL
, /* FIXME: i18n: */
3078 &setlist
, &showlist
);
3080 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3081 Set whether to display memory accesses in child process."), _("\
3082 Show whether to display memory accesses in child process."), NULL
,
3084 NULL
, /* FIXME: i18n: */
3085 &setlist
, &showlist
);
3087 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3088 &debug_exceptions
, _("\
3089 Set whether to display kernel exceptions in child process."), _("\
3090 Show whether to display kernel exceptions in child process."), NULL
,
3092 NULL
, /* FIXME: i18n: */
3093 &setlist
, &showlist
);
3095 init_w32_command_list ();
3097 add_cmd ("selector", class_info
, display_selectors
,
3098 _("Display selectors infos."),
3102 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3104 /* Pass the address ADDR to the inferior in the I'th debug register.
3105 Here we just store the address in dr array, the registers will be
3106 actually set up when windows_continue is called. */
3108 cygwin_set_dr (int i
, CORE_ADDR addr
)
3111 internal_error (__FILE__
, __LINE__
,
3112 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3114 debug_registers_changed
= 1;
3115 debug_registers_used
= 1;
3118 /* Pass the value VAL to the inferior in the DR7 debug control
3119 register. Here we just store the address in D_REGS, the watchpoint
3120 will be actually set up in windows_wait. */
3122 cygwin_set_dr7 (unsigned long val
)
3124 dr
[7] = (CORE_ADDR
) val
;
3125 debug_registers_changed
= 1;
3126 debug_registers_used
= 1;
3129 /* Get the value of debug register I from the inferior. */
3132 cygwin_get_dr (int i
)
3137 /* Get the value of the DR6 debug status register from the inferior.
3138 Here we just return the value stored in dr[6]
3139 by the last call to thread_rec for current_event.dwThreadId id. */
3140 static unsigned long
3141 cygwin_get_dr6 (void)
3143 return (unsigned long) dr
[6];
3146 /* Get the value of the DR7 debug status register from the inferior.
3147 Here we just return the value stored in dr[7] by the last call to
3148 thread_rec for current_event.dwThreadId id. */
3150 static unsigned long
3151 cygwin_get_dr7 (void)
3153 return (unsigned long) dr
[7];
3156 /* Determine if the thread referenced by "ptid" is alive
3157 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3158 it means that the thread has died. Otherwise it is assumed to be alive. */
3161 windows_nat_target::thread_alive (ptid_t ptid
)
3165 gdb_assert (ptid_get_tid (ptid
) != 0);
3166 tid
= ptid_get_tid (ptid
);
3168 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3172 _initialize_check_for_gdb_ini (void)
3175 if (inhibit_gdbinit
)
3178 homedir
= getenv ("HOME");
3182 char *oldini
= (char *) alloca (strlen (homedir
) +
3183 sizeof ("gdb.ini") + 1);
3184 strcpy (oldini
, homedir
);
3185 p
= strchr (oldini
, '\0');
3186 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3188 strcpy (p
, "gdb.ini");
3189 if (access (oldini
, 0) == 0)
3191 int len
= strlen (oldini
);
3192 char *newini
= (char *) alloca (len
+ 2);
3194 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3195 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3196 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3201 /* Define dummy functions which always return error for the rare cases where
3202 these functions could not be found. */
3204 bad_DebugActiveProcessStop (DWORD w
)
3209 bad_DebugBreakProcess (HANDLE w
)
3214 bad_DebugSetProcessKillOnExit (BOOL w
)
3219 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3226 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3232 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3239 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3245 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3251 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3257 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3265 /* Load any functions which may not be available in ancient versions
3269 _initialize_loadable (void)
3273 #define GPA(m, func) \
3274 func = (func ## _ftype *) GetProcAddress (m, #func)
3276 hm
= LoadLibrary ("kernel32.dll");
3279 GPA (hm
, DebugActiveProcessStop
);
3280 GPA (hm
, DebugBreakProcess
);
3281 GPA (hm
, DebugSetProcessKillOnExit
);
3282 GPA (hm
, GetConsoleFontSize
);
3283 GPA (hm
, DebugActiveProcessStop
);
3284 GPA (hm
, GetCurrentConsoleFont
);
3287 /* Set variables to dummy versions of these processes if the function
3288 wasn't found in kernel32.dll. */
3289 if (!DebugBreakProcess
)
3290 DebugBreakProcess
= bad_DebugBreakProcess
;
3291 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3293 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3294 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3296 if (!GetConsoleFontSize
)
3297 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3298 if (!GetCurrentConsoleFont
)
3299 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3301 /* Load optional functions used for retrieving filename information
3302 associated with the currently debugged process or its dlls. */
3303 hm
= LoadLibrary ("psapi.dll");
3306 GPA (hm
, EnumProcessModules
);
3307 GPA (hm
, GetModuleInformation
);
3308 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3309 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3312 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3314 /* Set variables to dummy versions of these processes if the function
3315 wasn't found in psapi.dll. */
3316 EnumProcessModules
= bad_EnumProcessModules
;
3317 GetModuleInformation
= bad_GetModuleInformation
;
3318 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3319 /* This will probably fail on Windows 9x/Me. Let the user know
3320 that we're missing some functionality. */
3322 cannot automatically find executable file or library to read symbols.\n\
3323 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3326 hm
= LoadLibrary ("advapi32.dll");
3329 GPA (hm
, OpenProcessToken
);
3330 GPA (hm
, LookupPrivilegeValueA
);
3331 GPA (hm
, AdjustTokenPrivileges
);
3332 /* Only need to set one of these since if OpenProcessToken fails nothing
3334 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3335 || !AdjustTokenPrivileges
)
3336 OpenProcessToken
= bad_OpenProcessToken
;