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
150 static CONTEXT saved_context
; /* Containes the saved context from a
154 /* If we're not using the old Cygwin header file set, define the
155 following which never should have been in the generic Win32 API
156 headers in the first place since they were our own invention... */
157 #ifndef _GNU_H_WINDOWS_H
160 FLAG_TRACE_BIT
= 0x100,
164 #ifndef CONTEXT_EXTENDED_REGISTERS
165 /* This macro is only defined on ia32. It only makes sense on this target,
166 so define it as zero if not already defined. */
167 #define CONTEXT_EXTENDED_REGISTERS 0
170 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
171 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
172 | CONTEXT_EXTENDED_REGISTERS
174 static uintptr_t dr
[8];
175 static int debug_registers_changed
;
176 static int debug_registers_used
;
178 static int windows_initialization_done
;
179 #define DR6_CLEAR_VALUE 0xffff0ff0
181 /* The exception thrown by a program to tell the debugger the name of
182 a thread. The exception record contains an ID of a thread and a
183 name to give it. This exception has no documented name, but MSDN
184 dubs it "MS_VC_EXCEPTION" in one code example. */
185 #define MS_VC_EXCEPTION 0x406d1388
189 HANDLE_EXCEPTION_UNHANDLED
= 0,
190 HANDLE_EXCEPTION_HANDLED
,
191 HANDLE_EXCEPTION_IGNORED
192 } handle_exception_result
;
194 /* The string sent by cygwin when it processes a signal.
195 FIXME: This should be in a cygwin include file. */
196 #ifndef _CYGWIN_SIGNAL_STRING
197 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
200 #define CHECK(x) check (x, __FILE__,__LINE__)
201 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
202 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
203 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
204 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
206 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
207 static void cygwin_set_dr7 (unsigned long val
);
208 static CORE_ADDR
cygwin_get_dr (int i
);
209 static unsigned long cygwin_get_dr6 (void);
210 static unsigned long cygwin_get_dr7 (void);
212 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
213 /* Set if a signal was received from the debugged process. */
215 /* Thread information structure used to track information that is
216 not available in gdb's thread structure. */
217 typedef struct windows_thread_info_struct
219 struct windows_thread_info_struct
*next
;
222 CORE_ADDR thread_local_base
;
231 static windows_thread_info thread_head
;
233 /* The process and thread handles for the above context. */
235 static DEBUG_EVENT current_event
; /* The current debug event from
237 static HANDLE current_process_handle
; /* Currently executing process */
238 static windows_thread_info
*current_thread
; /* Info on currently selected thread */
239 static DWORD main_thread_id
; /* Thread ID of the main thread */
241 /* Counts of things. */
242 static int exception_count
= 0;
243 static int event_count
= 0;
244 static int saw_create
;
245 static int open_process_used
= 0;
248 static int new_console
= 0;
250 static int cygwin_exceptions
= 0;
252 static int new_group
= 1;
253 static int debug_exec
= 0; /* show execution */
254 static int debug_events
= 0; /* show events from kernel */
255 static int debug_memory
= 0; /* show target memory accesses */
256 static int debug_exceptions
= 0; /* show target exceptions */
257 static int useshell
= 0; /* use shell for subprocesses */
259 /* This vector maps GDB's idea of a register's number into an offset
260 in the windows exception context vector.
262 It also contains the bit mask needed to load the register in question.
264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
267 windows_set_context_register_offsets.
269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
272 context already contains what we need, we just unpack it. Then to
273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
277 static const int *mappings
;
279 /* The function to use in order to determine whether a register is
280 a segment register or not. */
281 static segment_register_p_ftype
*segment_register_p
;
283 /* See windows_nat_target::resume to understand why this is commented
286 /* This vector maps the target's idea of an exception (extracted
287 from the DEBUG_EVENT structure) to GDB's idea. */
289 struct xlate_exception
295 static const struct xlate_exception xlate
[] =
297 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
298 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
299 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
300 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
301 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
302 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
307 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
309 void close () override
;
311 void attach (const char *, int) override
;
313 bool attach_no_wait () override
316 void detach (inferior
*, int) override
;
318 void resume (ptid_t
, int , enum gdb_signal
) override
;
320 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
322 void fetch_registers (struct regcache
*, int) override
;
323 void store_registers (struct regcache
*, int) override
;
325 enum target_xfer_status
xfer_partial (enum target_object object
,
328 const gdb_byte
*writebuf
,
329 ULONGEST offset
, ULONGEST len
,
330 ULONGEST
*xfered_len
) override
;
332 void files_info () override
;
334 void kill () override
;
336 void create_inferior (const char *, const std::string
&,
337 char **, int) override
;
339 void mourn_inferior () override
;
341 bool thread_alive (ptid_t ptid
) override
;
343 const char *pid_to_str (ptid_t
) override
;
345 void interrupt () override
;
347 char *pid_to_exec_file (int pid
) override
;
349 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
351 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
353 const char *thread_name (struct thread_info
*) override
;
356 static windows_nat_target the_windows_nat_target
;
358 /* Set the MAPPINGS static global to OFFSETS.
359 See the description of MAPPINGS for more details. */
362 windows_set_context_register_offsets (const int *offsets
)
367 /* See windows-nat.h. */
370 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
372 segment_register_p
= fun
;
376 check (BOOL ok
, const char *file
, int line
)
379 printf_filtered ("error return %s:%d was %u\n", file
, line
,
380 (unsigned) GetLastError ());
383 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
384 then also retrieve the context for this thread. If GET_CONTEXT is
385 negative, then don't suspend the thread. */
386 static windows_thread_info
*
387 thread_rec (DWORD id
, int get_context
)
389 windows_thread_info
*th
;
391 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
394 if (!th
->suspended
&& get_context
)
396 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
398 if (SuspendThread (th
->h
) == (DWORD
) -1)
400 DWORD err
= GetLastError ();
402 /* We get Access Denied (5) when trying to suspend
403 threads that Windows started on behalf of the
404 debuggee, usually when those threads are just
406 We can get Invalid Handle (6) if the main thread
408 if (err
!= ERROR_INVALID_HANDLE
409 && err
!= ERROR_ACCESS_DENIED
)
410 warning (_("SuspendThread (tid=0x%x) failed."
412 (unsigned) id
, (unsigned) err
);
418 else if (get_context
< 0)
420 th
->reload_context
= 1;
428 /* Add a thread to the thread list. */
429 static windows_thread_info
*
430 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
432 windows_thread_info
*th
;
435 gdb_assert (ptid
.tid () != 0);
439 if ((th
= thread_rec (id
, FALSE
)))
442 th
= XCNEW (windows_thread_info
);
445 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
446 th
->next
= thread_head
.next
;
447 thread_head
.next
= th
;
449 /* Set the debug registers for the new thread if they are used. */
450 if (debug_registers_used
)
452 /* Only change the value of the debug registers. */
453 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
454 CHECK (GetThreadContext (th
->h
, &th
->context
));
455 th
->context
.Dr0
= dr
[0];
456 th
->context
.Dr1
= dr
[1];
457 th
->context
.Dr2
= dr
[2];
458 th
->context
.Dr3
= dr
[3];
459 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
460 th
->context
.Dr7
= dr
[7];
461 CHECK (SetThreadContext (th
->h
, &th
->context
));
462 th
->context
.ContextFlags
= 0;
467 /* Clear out any old thread list and reinitialize it to a
470 windows_init_thread_list (void)
472 windows_thread_info
*th
= &thread_head
;
474 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
476 while (th
->next
!= NULL
)
478 windows_thread_info
*here
= th
->next
;
479 th
->next
= here
->next
;
482 thread_head
.next
= NULL
;
485 /* Delete a thread from the list of threads. */
487 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
489 windows_thread_info
*th
;
492 gdb_assert (ptid
.tid () != 0);
497 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
498 else if (print_thread_events
&& id
!= main_thread_id
)
499 printf_unfiltered (_("[%s exited with code %u]\n"),
500 target_pid_to_str (ptid
), (unsigned) exit_code
);
501 delete_thread (find_thread_ptid (ptid
));
503 for (th
= &thread_head
;
504 th
->next
!= NULL
&& th
->next
->id
!= id
;
508 if (th
->next
!= NULL
)
510 windows_thread_info
*here
= th
->next
;
511 th
->next
= here
->next
;
517 /* Fetches register number R from the given windows_thread_info,
518 and supplies its value to the given regcache.
520 This function assumes that R is non-negative. A failed assertion
521 is raised if that is not true.
523 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
524 that the windows_thread_info has an up-to-date context. A failed
525 assertion is raised if that assumption is violated. */
528 windows_fetch_one_register (struct regcache
*regcache
,
529 windows_thread_info
*th
, int r
)
532 gdb_assert (!th
->reload_context
);
534 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
535 struct gdbarch
*gdbarch
= regcache
->arch ();
536 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
538 if (r
== I387_FISEG_REGNUM (tdep
))
540 long l
= *((long *) context_offset
) & 0xffff;
541 regcache
->raw_supply (r
, (char *) &l
);
543 else if (r
== I387_FOP_REGNUM (tdep
))
545 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
546 regcache
->raw_supply (r
, (char *) &l
);
548 else if (segment_register_p (r
))
550 /* GDB treats segment registers as 32bit registers, but they are
551 in fact only 16 bits long. Make sure we do not read extra
552 bits from our source buffer. */
553 long l
= *((long *) context_offset
) & 0xffff;
554 regcache
->raw_supply (r
, (char *) &l
);
557 regcache
->raw_supply (r
, context_offset
);
561 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
563 DWORD pid
= regcache
->ptid ().tid ();
564 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
566 /* Check if TH exists. Windows sometimes uses a non-existent
567 thread id in its events. */
571 if (th
->reload_context
)
574 if (have_saved_context
)
576 /* Lie about where the program actually is stopped since
577 cygwin has informed us that we should consider the signal
578 to have occurred at another location which is stored in
580 memcpy (&th
->context
, &saved_context
,
581 __COPY_CONTEXT_SIZE
);
582 have_saved_context
= 0;
587 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
588 CHECK (GetThreadContext (th
->h
, &th
->context
));
589 /* Copy dr values from that thread.
590 But only if there were not modified since last stop.
592 if (!debug_registers_changed
)
594 dr
[0] = th
->context
.Dr0
;
595 dr
[1] = th
->context
.Dr1
;
596 dr
[2] = th
->context
.Dr2
;
597 dr
[3] = th
->context
.Dr3
;
598 dr
[6] = th
->context
.Dr6
;
599 dr
[7] = th
->context
.Dr7
;
602 th
->reload_context
= 0;
606 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
607 windows_fetch_one_register (regcache
, th
, r
);
609 windows_fetch_one_register (regcache
, th
, r
);
612 /* Collect the register number R from the given regcache, and store
613 its value into the corresponding area of the given thread's context.
615 This function assumes that R is non-negative. A failed assertion
616 assertion is raised if that is not true. */
619 windows_store_one_register (const struct regcache
*regcache
,
620 windows_thread_info
*th
, int r
)
624 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
627 /* Store a new register value into the context of the thread tied to
631 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
633 DWORD pid
= regcache
->ptid ().tid ();
634 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
636 /* Check if TH exists. Windows sometimes uses a non-existent
637 thread id in its events. */
642 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
643 windows_store_one_register (regcache
, th
, r
);
645 windows_store_one_register (regcache
, th
, r
);
648 /* Encapsulate the information required in a call to
649 symbol_file_add_args. */
650 struct safe_symbol_file_add_args
654 section_addr_info
*addrs
;
657 struct ui_file
*err
, *out
;
661 /* Maintain a linked list of "so" information. */
662 struct lm_info_windows
: public lm_info_base
664 LPVOID load_addr
= 0;
667 static struct so_list solib_start
, *solib_end
;
669 static struct so_list
*
670 windows_make_so (const char *name
, LPVOID load_addr
)
677 WIN32_FIND_DATA w32_fd
;
678 HANDLE h
= FindFirstFile(name
, &w32_fd
);
680 if (h
== INVALID_HANDLE_VALUE
)
686 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
688 p
= strrchr (buf
, '\\');
691 SetCurrentDirectory (buf
);
692 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
693 SetCurrentDirectory (cwd
);
696 if (strcasecmp (buf
, "ntdll.dll") == 0)
698 GetSystemDirectory (buf
, sizeof (buf
));
699 strcat (buf
, "\\ntdll.dll");
702 cygwin_buf_t buf
[__PMAX
];
705 if (access (name
, F_OK
) != 0)
707 if (strcasecmp (name
, "ntdll.dll") == 0)
710 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
711 wcscat (buf
, L
"\\ntdll.dll");
715 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
716 strcat (buf
, "\\ntdll.dll");
721 so
= XCNEW (struct so_list
);
722 lm_info_windows
*li
= new lm_info_windows
;
724 li
->load_addr
= load_addr
;
725 strcpy (so
->so_original_name
, name
);
727 strcpy (so
->so_name
, buf
);
730 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
731 SO_NAME_MAX_PATH_SIZE
);
734 char *rname
= realpath (name
, NULL
);
735 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
737 strcpy (so
->so_name
, rname
);
741 error (_("dll path too long"));
743 /* Record cygwin1.dll .text start/end. */
744 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
745 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
747 asection
*text
= NULL
;
750 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
755 if (bfd_check_format (abfd
.get (), bfd_object
))
756 text
= bfd_get_section_by_name (abfd
.get (), ".text");
761 /* The symbols in a dll are offset by 0x1000, which is the
762 offset from 0 of the first byte in an image - because of the
763 file header and the section alignment. */
764 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
766 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
.get (),
775 get_image_name (HANDLE h
, void *address
, int unicode
)
778 static char buf
[__PMAX
];
780 static char buf
[(2 * __PMAX
) + 1];
782 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
788 /* Attempt to read the name of the dll that was detected.
789 This is documented to work only when actively debugging
790 a program. It will not work for attached processes. */
794 /* See if we could read the address of a string, and that the
795 address isn't null. */
796 if (!ReadProcessMemory (h
, address
, &address_ptr
,
797 sizeof (address_ptr
), &done
)
798 || done
!= sizeof (address_ptr
) || !address_ptr
)
801 /* Find the length of the string. */
802 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
803 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
807 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
810 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
811 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
814 wcstombs (buf
, unicode_address
, __PMAX
);
816 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
824 /* Handle a DLL load event, and return 1.
826 This function assumes that this event did not occur during inferior
827 initialization, where their event info may be incomplete (see
828 do_initial_windows_stuff and windows_add_all_dlls for more info
829 on how we handle DLL loading during that phase). */
834 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
837 /* Try getting the DLL name via the lpImageName field of the event.
838 Note that Microsoft documents this fields as strictly optional,
839 in the sense that it might be NULL. And the first DLL event in
840 particular is explicitly documented as "likely not pass[ed]"
841 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
842 dll_name
= get_image_name (current_process_handle
,
843 event
->lpImageName
, event
->fUnicode
);
847 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
848 solib_end
= solib_end
->next
;
850 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
852 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
853 host_address_to_string (li
->load_addr
)));
857 windows_free_so (struct so_list
*so
)
859 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
865 /* Handle a DLL unload event.
866 Return 1 if successful, or zero otherwise.
868 This function assumes that this event did not occur during inferior
869 initialization, where their event info may be incomplete (see
870 do_initial_windows_stuff and windows_add_all_dlls for more info
871 on how we handle DLL loading during that phase). */
876 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
879 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
881 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
883 if (li_next
->load_addr
== lpBaseOfDll
)
885 struct so_list
*sodel
= so
->next
;
887 so
->next
= sodel
->next
;
890 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
892 windows_free_so (sodel
);
897 /* We did not find any DLL that was previously loaded at this address,
898 so register a complaint. We do not report an error, because we have
899 observed that this may be happening under some circumstances. For
900 instance, running 32bit applications on x64 Windows causes us to receive
901 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
902 events are apparently caused by the WOW layer, the interface between
903 32bit and 64bit worlds). */
904 complaint (_("dll starting at %s not found."),
905 host_address_to_string (lpBaseOfDll
));
908 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
912 catch_errors (void (*func
) ())
918 CATCH (ex
, RETURN_MASK_ALL
)
920 exception_print (gdb_stderr
, ex
);
925 /* Clear list of loaded DLLs. */
927 windows_clear_solib (void)
929 solib_start
.next
= NULL
;
930 solib_end
= &solib_start
;
934 signal_event_command (const char *args
, int from_tty
)
936 uintptr_t event_id
= 0;
937 char *endargs
= NULL
;
940 error (_("signal-event requires an argument (integer event id)"));
942 event_id
= strtoumax (args
, &endargs
, 10);
944 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
945 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
946 error (_("Failed to convert `%s' to event id"), args
);
948 SetEvent ((HANDLE
) event_id
);
949 CloseHandle ((HANDLE
) event_id
);
952 /* Handle DEBUG_STRING output from child process.
953 Cygwin prepends its messages with a "cygwin:". Interpret this as
954 a Cygwin signal. Otherwise just print the string as a warning. */
956 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
958 gdb::unique_xmalloc_ptr
<char> s
;
961 if (!target_read_string
962 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
964 || !s
|| !*(s
.get ()))
966 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
969 if (!startswith (s
.get (), "cYg"))
972 char *p
= strchr (s
.get (), '\0');
974 if (p
> s
.get () && *--p
== '\n')
976 warning (("%s"), s
.get ());
982 /* Got a cygwin signal marker. A cygwin signal is followed by
983 the signal number itself and then optionally followed by the
984 thread id and address to saved context within the DLL. If
985 these are supplied, then the given thread is assumed to have
986 issued the signal and the context from the thread is assumed
987 to be stored at the given address in the inferior. Tell gdb
988 to treat this like a real signal. */
990 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
991 gdb_signal gotasig
= gdb_signal_from_host (sig
);
993 ourstatus
->value
.sig
= gotasig
;
999 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1000 retval
= strtoul (p
, &p
, 0);
1002 retval
= main_thread_id
;
1003 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1004 && ReadProcessMemory (current_process_handle
, x
,
1006 __COPY_CONTEXT_SIZE
, &n
)
1007 && n
== __COPY_CONTEXT_SIZE
)
1008 have_saved_context
= 1;
1017 display_selector (HANDLE thread
, DWORD sel
)
1020 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1023 printf_filtered ("0x%03x: ", (unsigned) sel
);
1024 if (!info
.HighWord
.Bits
.Pres
)
1026 puts_filtered ("Segment not present\n");
1029 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1030 (info
.HighWord
.Bits
.BaseMid
<< 16)
1032 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1033 if (info
.HighWord
.Bits
.Granularity
)
1034 limit
= (limit
<< 12) | 0xfff;
1035 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1036 if (info
.HighWord
.Bits
.Default_Big
)
1037 puts_filtered(" 32-bit ");
1039 puts_filtered(" 16-bit ");
1040 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1043 puts_filtered ("Data (Read-Only, Exp-up");
1046 puts_filtered ("Data (Read/Write, Exp-up");
1049 puts_filtered ("Unused segment (");
1052 puts_filtered ("Data (Read/Write, Exp-down");
1055 puts_filtered ("Code (Exec-Only, N.Conf");
1058 puts_filtered ("Code (Exec/Read, N.Conf");
1061 puts_filtered ("Code (Exec-Only, Conf");
1064 puts_filtered ("Code (Exec/Read, Conf");
1067 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1069 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1070 puts_filtered(", N.Acc");
1071 puts_filtered (")\n");
1072 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1073 puts_filtered("System selector ");
1074 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1075 if (info
.HighWord
.Bits
.Granularity
)
1076 puts_filtered ("Page granular.\n");
1078 puts_filtered ("Byte granular.\n");
1083 DWORD err
= GetLastError ();
1084 if (err
== ERROR_NOT_SUPPORTED
)
1085 printf_filtered ("Function not supported\n");
1087 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1093 display_selectors (const char * args
, int from_tty
)
1095 if (!current_thread
)
1097 puts_filtered ("Impossible to display selectors now.\n");
1103 puts_filtered ("Selector $cs\n");
1104 display_selector (current_thread
->h
,
1105 current_thread
->context
.SegCs
);
1106 puts_filtered ("Selector $ds\n");
1107 display_selector (current_thread
->h
,
1108 current_thread
->context
.SegDs
);
1109 puts_filtered ("Selector $es\n");
1110 display_selector (current_thread
->h
,
1111 current_thread
->context
.SegEs
);
1112 puts_filtered ("Selector $ss\n");
1113 display_selector (current_thread
->h
,
1114 current_thread
->context
.SegSs
);
1115 puts_filtered ("Selector $fs\n");
1116 display_selector (current_thread
->h
,
1117 current_thread
->context
.SegFs
);
1118 puts_filtered ("Selector $gs\n");
1119 display_selector (current_thread
->h
,
1120 current_thread
->context
.SegGs
);
1125 sel
= parse_and_eval_long (args
);
1126 printf_filtered ("Selector \"%s\"\n",args
);
1127 display_selector (current_thread
->h
, sel
);
1131 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1132 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1133 host_address_to_string (\
1134 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1136 static handle_exception_result
1137 handle_exception (struct target_waitstatus
*ourstatus
)
1139 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1140 DWORD code
= rec
->ExceptionCode
;
1141 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1143 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1145 /* Record the context of the current thread. */
1146 thread_rec (current_event
.dwThreadId
, -1);
1150 case EXCEPTION_ACCESS_VIOLATION
:
1151 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1152 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1155 /* See if the access violation happened within the cygwin DLL
1156 itself. Cygwin uses a kind of exception handling to deal
1157 with passed-in invalid addresses. gdb should not treat
1158 these as real SEGVs since they will be silently handled by
1159 cygwin. A real SEGV will (theoretically) be caught by
1160 cygwin later in the process and will be sent as a
1161 cygwin-specific-signal. So, ignore SEGVs if they show up
1162 within the text segment of the DLL itself. */
1164 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1166 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1167 && addr
< cygwin_load_end
))
1168 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1169 && startswith (fn
, "KERNEL32!IsBad")))
1170 return HANDLE_EXCEPTION_UNHANDLED
;
1174 case STATUS_STACK_OVERFLOW
:
1175 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1176 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1178 case STATUS_FLOAT_DENORMAL_OPERAND
:
1179 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1180 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1182 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1183 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1184 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1186 case STATUS_FLOAT_INEXACT_RESULT
:
1187 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1188 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1190 case STATUS_FLOAT_INVALID_OPERATION
:
1191 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1192 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1194 case STATUS_FLOAT_OVERFLOW
:
1195 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1196 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1198 case STATUS_FLOAT_STACK_CHECK
:
1199 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1200 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1202 case STATUS_FLOAT_UNDERFLOW
:
1203 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1204 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1206 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1207 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1208 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1210 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1211 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1212 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1214 case STATUS_INTEGER_OVERFLOW
:
1215 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1216 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1218 case EXCEPTION_BREAKPOINT
:
1219 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1220 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1223 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1224 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1226 case DBG_CONTROL_BREAK
:
1227 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1228 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1230 case EXCEPTION_SINGLE_STEP
:
1231 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1232 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1234 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1235 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1236 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1238 case EXCEPTION_PRIV_INSTRUCTION
:
1239 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1240 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1242 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1243 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1244 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1246 case MS_VC_EXCEPTION
:
1247 if (rec
->NumberParameters
>= 3
1248 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1250 DWORD named_thread_id
;
1251 windows_thread_info
*named_thread
;
1252 CORE_ADDR thread_name_target
;
1254 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1256 thread_name_target
= rec
->ExceptionInformation
[1];
1257 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1259 if (named_thread_id
== (DWORD
) -1)
1260 named_thread_id
= current_event
.dwThreadId
;
1262 named_thread
= thread_rec (named_thread_id
, 0);
1263 if (named_thread
!= NULL
)
1265 int thread_name_len
;
1266 gdb::unique_xmalloc_ptr
<char> thread_name
;
1268 thread_name_len
= target_read_string (thread_name_target
,
1269 &thread_name
, 1025, NULL
);
1270 if (thread_name_len
> 0)
1272 thread_name
.get ()[thread_name_len
- 1] = '\0';
1273 xfree (named_thread
->name
);
1274 named_thread
->name
= thread_name
.release ();
1277 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1278 result
= HANDLE_EXCEPTION_IGNORED
;
1281 /* treat improperly formed exception as unknown */
1284 /* Treat unhandled first chance exceptions specially. */
1285 if (current_event
.u
.Exception
.dwFirstChance
)
1286 return HANDLE_EXCEPTION_UNHANDLED
;
1287 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1288 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1289 host_address_to_string (
1290 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1291 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1295 last_sig
= ourstatus
->value
.sig
;
1299 /* Resume thread specified by ID, or all artificially suspended
1300 threads, if we are continuing execution. KILLED non-zero means we
1301 have killed the inferior, so we should ignore weird errors due to
1302 threads shutting down. */
1304 windows_continue (DWORD continue_status
, int id
, int killed
)
1306 windows_thread_info
*th
;
1309 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1310 (unsigned) current_event
.dwProcessId
,
1311 (unsigned) current_event
.dwThreadId
,
1312 continue_status
== DBG_CONTINUE
?
1313 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1315 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1316 if ((id
== -1 || id
== (int) th
->id
)
1319 if (debug_registers_changed
)
1321 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1322 th
->context
.Dr0
= dr
[0];
1323 th
->context
.Dr1
= dr
[1];
1324 th
->context
.Dr2
= dr
[2];
1325 th
->context
.Dr3
= dr
[3];
1326 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1327 th
->context
.Dr7
= dr
[7];
1329 if (th
->context
.ContextFlags
)
1333 if (GetExitCodeThread (th
->h
, &ec
)
1334 && ec
== STILL_ACTIVE
)
1336 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1341 th
->context
.ContextFlags
= 0;
1343 if (th
->suspended
> 0)
1344 (void) ResumeThread (th
->h
);
1348 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1349 current_event
.dwThreadId
,
1353 error (_("Failed to resume program execution"
1354 " (ContinueDebugEvent failed, error %u)"),
1355 (unsigned int) GetLastError ());
1357 debug_registers_changed
= 0;
1361 /* Called in pathological case where Windows fails to send a
1362 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1364 fake_create_process (void)
1366 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1367 current_event
.dwProcessId
);
1368 if (current_process_handle
!= NULL
)
1369 open_process_used
= 1;
1372 error (_("OpenProcess call failed, GetLastError = %u"),
1373 (unsigned) GetLastError ());
1374 /* We can not debug anything in that case. */
1376 main_thread_id
= current_event
.dwThreadId
;
1377 current_thread
= windows_add_thread (
1378 ptid_t (current_event
.dwProcessId
, 0,
1379 current_event
.dwThreadId
),
1380 current_event
.u
.CreateThread
.hThread
,
1381 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1382 return main_thread_id
;
1386 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1388 windows_thread_info
*th
;
1389 DWORD continue_status
= DBG_CONTINUE
;
1391 /* A specific PTID means `step only this thread id'. */
1392 int resume_all
= ptid
== minus_one_ptid
;
1394 /* If we're continuing all threads, it's the current inferior that
1395 should be handled specially. */
1397 ptid
= inferior_ptid
;
1399 if (sig
!= GDB_SIGNAL_0
)
1401 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1403 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1405 else if (sig
== last_sig
)
1406 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1409 /* This code does not seem to work, because
1410 the kernel does probably not consider changes in the ExceptionRecord
1411 structure when passing the exception to the inferior.
1412 Note that this seems possible in the exception handler itself. */
1414 for (const xlate_exception
&x
: xlate
)
1417 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1419 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1422 if (continue_status
== DBG_CONTINUE
)
1424 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1428 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1432 last_sig
= GDB_SIGNAL_0
;
1434 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1435 ptid
.pid (), ptid
.tid (), step
, sig
));
1437 /* Get context for currently selected thread. */
1438 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1443 /* Single step by setting t bit. */
1444 struct regcache
*regcache
= get_current_regcache ();
1445 struct gdbarch
*gdbarch
= regcache
->arch ();
1446 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1447 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1450 if (th
->context
.ContextFlags
)
1452 if (debug_registers_changed
)
1454 th
->context
.Dr0
= dr
[0];
1455 th
->context
.Dr1
= dr
[1];
1456 th
->context
.Dr2
= dr
[2];
1457 th
->context
.Dr3
= dr
[3];
1458 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1459 th
->context
.Dr7
= dr
[7];
1461 CHECK (SetThreadContext (th
->h
, &th
->context
));
1462 th
->context
.ContextFlags
= 0;
1466 /* Allow continuing with the same signal that interrupted us.
1467 Otherwise complain. */
1470 windows_continue (continue_status
, -1, 0);
1472 windows_continue (continue_status
, ptid
.tid (), 0);
1475 /* Ctrl-C handler used when the inferior is not run in the same console. The
1476 handler is in charge of interrupting the inferior using DebugBreakProcess.
1477 Note that this function is not available prior to Windows XP. In this case
1478 we emit a warning. */
1480 ctrl_c_handler (DWORD event_type
)
1482 const int attach_flag
= current_inferior ()->attach_flag
;
1484 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1485 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1488 /* If the inferior and the debugger share the same console, do nothing as
1489 the inferior has also received the Ctrl-C event. */
1490 if (!new_console
&& !attach_flag
)
1493 if (!DebugBreakProcess (current_process_handle
))
1494 warning (_("Could not interrupt program. "
1495 "Press Ctrl-c in the program console."));
1497 /* Return true to tell that Ctrl-C has been handled. */
1501 /* Get the next event from the child. Returns a non-zero thread id if the event
1502 requires handling by WFI (or whatever). */
1504 get_windows_debug_event (struct target_ops
*ops
,
1505 int pid
, struct target_waitstatus
*ourstatus
)
1508 DWORD continue_status
, event_code
;
1509 windows_thread_info
*th
;
1510 static windows_thread_info dummy_thread_info
;
1511 DWORD thread_id
= 0;
1513 last_sig
= GDB_SIGNAL_0
;
1515 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1519 continue_status
= DBG_CONTINUE
;
1521 event_code
= current_event
.dwDebugEventCode
;
1522 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1524 have_saved_context
= 0;
1528 case CREATE_THREAD_DEBUG_EVENT
:
1529 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1530 (unsigned) current_event
.dwProcessId
,
1531 (unsigned) current_event
.dwThreadId
,
1532 "CREATE_THREAD_DEBUG_EVENT"));
1533 if (saw_create
!= 1)
1535 struct inferior
*inf
;
1536 inf
= find_inferior_pid (current_event
.dwProcessId
);
1537 if (!saw_create
&& inf
->attach_flag
)
1539 /* Kludge around a Windows bug where first event is a create
1540 thread event. Caused when attached process does not have
1542 thread_id
= fake_create_process ();
1548 /* Record the existence of this thread. */
1549 thread_id
= current_event
.dwThreadId
;
1550 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1551 current_event
.dwThreadId
),
1552 current_event
.u
.CreateThread
.hThread
,
1553 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1557 case EXIT_THREAD_DEBUG_EVENT
:
1558 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1559 (unsigned) current_event
.dwProcessId
,
1560 (unsigned) current_event
.dwThreadId
,
1561 "EXIT_THREAD_DEBUG_EVENT"));
1563 if (current_event
.dwThreadId
!= main_thread_id
)
1565 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1566 current_event
.dwThreadId
),
1567 current_event
.u
.ExitThread
.dwExitCode
);
1568 th
= &dummy_thread_info
;
1572 case CREATE_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 "CREATE_PROCESS_DEBUG_EVENT"));
1577 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1578 if (++saw_create
!= 1)
1581 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1583 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1586 main_thread_id
= current_event
.dwThreadId
;
1587 /* Add the main thread. */
1588 th
= windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1589 current_event
.dwThreadId
),
1590 current_event
.u
.CreateProcessInfo
.hThread
,
1591 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1592 thread_id
= current_event
.dwThreadId
;
1595 case EXIT_PROCESS_DEBUG_EVENT
:
1596 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1597 (unsigned) current_event
.dwProcessId
,
1598 (unsigned) current_event
.dwThreadId
,
1599 "EXIT_PROCESS_DEBUG_EVENT"));
1600 if (!windows_initialization_done
)
1602 target_terminal::ours ();
1603 target_mourn_inferior (inferior_ptid
);
1604 error (_("During startup program exited with code 0x%x."),
1605 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1607 else if (saw_create
== 1)
1609 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1610 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1611 thread_id
= main_thread_id
;
1615 case LOAD_DLL_DEBUG_EVENT
:
1616 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1617 (unsigned) current_event
.dwProcessId
,
1618 (unsigned) current_event
.dwThreadId
,
1619 "LOAD_DLL_DEBUG_EVENT"));
1620 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1621 if (saw_create
!= 1 || ! windows_initialization_done
)
1623 catch_errors (handle_load_dll
);
1624 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1625 ourstatus
->value
.integer
= 0;
1626 thread_id
= main_thread_id
;
1629 case UNLOAD_DLL_DEBUG_EVENT
:
1630 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1631 (unsigned) current_event
.dwProcessId
,
1632 (unsigned) current_event
.dwThreadId
,
1633 "UNLOAD_DLL_DEBUG_EVENT"));
1634 if (saw_create
!= 1 || ! windows_initialization_done
)
1636 catch_errors (handle_unload_dll
);
1637 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1638 ourstatus
->value
.integer
= 0;
1639 thread_id
= main_thread_id
;
1642 case EXCEPTION_DEBUG_EVENT
:
1643 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1644 (unsigned) current_event
.dwProcessId
,
1645 (unsigned) current_event
.dwThreadId
,
1646 "EXCEPTION_DEBUG_EVENT"));
1647 if (saw_create
!= 1)
1649 switch (handle_exception (ourstatus
))
1651 case HANDLE_EXCEPTION_UNHANDLED
:
1653 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1655 case HANDLE_EXCEPTION_HANDLED
:
1656 thread_id
= current_event
.dwThreadId
;
1658 case HANDLE_EXCEPTION_IGNORED
:
1659 continue_status
= DBG_CONTINUE
;
1664 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1665 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1666 (unsigned) current_event
.dwProcessId
,
1667 (unsigned) current_event
.dwThreadId
,
1668 "OUTPUT_DEBUG_STRING_EVENT"));
1669 if (saw_create
!= 1)
1671 thread_id
= handle_output_debug_string (ourstatus
);
1675 if (saw_create
!= 1)
1677 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1678 (unsigned) current_event
.dwProcessId
,
1679 (unsigned) current_event
.dwThreadId
);
1680 printf_unfiltered (" unknown event code %u\n",
1681 (unsigned) current_event
.dwDebugEventCode
);
1685 if (!thread_id
|| saw_create
!= 1)
1687 CHECK (windows_continue (continue_status
, -1, 0));
1691 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1692 current_thread
= th
;
1693 if (!current_thread
)
1694 current_thread
= thread_rec (thread_id
, TRUE
);
1701 /* Wait for interesting events to occur in the target process. */
1703 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1708 target_terminal::ours ();
1710 /* We loop when we get a non-standard exception rather than return
1711 with a SPURIOUS because resume can try and step or modify things,
1712 which needs a current_thread->h. But some of these exceptions mark
1713 the birth or death of threads, which mean that the current thread
1714 isn't necessarily what you think it is. */
1720 /* If the user presses Ctrl-c while the debugger is waiting
1721 for an event, he expects the debugger to interrupt his program
1722 and to get the prompt back. There are two possible situations:
1724 - The debugger and the program do not share the console, in
1725 which case the Ctrl-c event only reached the debugger.
1726 In that case, the ctrl_c handler will take care of interrupting
1727 the inferior. Note that this case is working starting with
1728 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1731 - The debugger and the program share the same console, in which
1732 case both debugger and inferior will receive the Ctrl-c event.
1733 In that case the ctrl_c handler will ignore the event, as the
1734 Ctrl-c event generated inside the inferior will trigger the
1735 expected debug event.
1737 FIXME: brobecker/2008-05-20: If the inferior receives the
1738 signal first and the delay until GDB receives that signal
1739 is sufficiently long, GDB can sometimes receive the SIGINT
1740 after we have unblocked the CTRL+C handler. This would
1741 lead to the debugger stopping prematurely while handling
1742 the new-thread event that comes with the handling of the SIGINT
1743 inside the inferior, and then stop again immediately when
1744 the user tries to resume the execution in the inferior.
1745 This is a classic race that we should try to fix one day. */
1746 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1747 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1748 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1751 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1756 if (deprecated_ui_loop_hook
!= NULL
)
1757 detach
= deprecated_ui_loop_hook (0);
1765 /* Iterate over all DLLs currently mapped by our inferior, and
1766 add them to our list of solibs. */
1769 windows_add_all_dlls (void)
1771 HMODULE dummy_hmodule
;
1776 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1777 sizeof (HMODULE
), &cb_needed
) == 0)
1783 hmodules
= (HMODULE
*) alloca (cb_needed
);
1784 if (EnumProcessModules (current_process_handle
, hmodules
,
1785 cb_needed
, &cb_needed
) == 0)
1788 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1792 wchar_t dll_name
[__PMAX
];
1795 char dll_name
[__PMAX
];
1798 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1799 &mi
, sizeof (mi
)) == 0)
1801 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1802 dll_name
, sizeof (dll_name
)) == 0)
1805 wcstombs (name
, dll_name
, __PMAX
);
1810 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1811 solib_end
= solib_end
->next
;
1816 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1819 struct inferior
*inf
;
1821 last_sig
= GDB_SIGNAL_0
;
1823 exception_count
= 0;
1824 open_process_used
= 0;
1825 debug_registers_changed
= 0;
1826 debug_registers_used
= 0;
1827 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1830 cygwin_load_start
= cygwin_load_end
= 0;
1832 current_event
.dwProcessId
= pid
;
1833 memset (¤t_event
, 0, sizeof (current_event
));
1834 if (!target_is_pushed (ops
))
1836 disable_breakpoints_in_shlibs ();
1837 windows_clear_solib ();
1838 clear_proceed_status (0);
1839 init_wait_for_inferior ();
1841 inf
= current_inferior ();
1842 inferior_appeared (inf
, pid
);
1843 inf
->attach_flag
= attaching
;
1845 /* Make the new process the current inferior, so terminal handling
1846 can rely on it. When attaching, we don't know about any thread
1847 id here, but that's OK --- nothing should be referencing the
1848 current thread until we report an event out of windows_wait. */
1849 inferior_ptid
= ptid_t (pid
);
1851 target_terminal::init ();
1852 target_terminal::inferior ();
1854 windows_initialization_done
= 0;
1858 struct target_waitstatus status
;
1860 ops
->wait (minus_one_ptid
, &status
, 0);
1862 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1864 if (status
.kind
!= TARGET_WAITKIND_LOADED
1865 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1868 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1871 /* Now that the inferior has been started and all DLLs have been mapped,
1872 we can iterate over all DLLs and load them in.
1874 We avoid doing it any earlier because, on certain versions of Windows,
1875 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1876 we have seen on Windows 8.1 that the ntdll.dll load event does not
1877 include the DLL name, preventing us from creating an associated SO.
1878 A possible explanation is that ntdll.dll might be mapped before
1879 the SO info gets created by the Windows system -- ntdll.dll is
1880 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1881 do not seem to suffer from that problem.
1883 Rather than try to work around this sort of issue, it is much
1884 simpler to just ignore DLL load/unload events during the startup
1885 phase, and then process them all in one batch now. */
1886 windows_add_all_dlls ();
1888 windows_initialization_done
= 1;
1892 /* Try to set or remove a user privilege to the current process. Return -1
1893 if that fails, the previous setting of that privilege otherwise.
1895 This code is copied from the Cygwin source code and rearranged to allow
1896 dynamically loading of the needed symbols from advapi32 which is only
1897 available on NT/2K/XP. */
1899 set_process_privilege (const char *privilege
, BOOL enable
)
1901 HANDLE token_hdl
= NULL
;
1903 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1907 if (!OpenProcessToken (GetCurrentProcess (),
1908 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1912 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1915 new_priv
.PrivilegeCount
= 1;
1916 new_priv
.Privileges
[0].Luid
= restore_priv
;
1917 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1919 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1920 sizeof orig_priv
, &orig_priv
, &size
))
1923 /* Disabled, otherwise every `attach' in an unprivileged user session
1924 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1925 windows_attach(). */
1926 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1927 be enabled. GetLastError () returns an correct error code, though. */
1928 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1932 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1936 CloseHandle (token_hdl
);
1941 /* Attach to process PID, then initialize for debugging it. */
1944 windows_nat_target::attach (const char *args
, int from_tty
)
1949 pid
= parse_pid_to_attach (args
);
1951 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1953 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1954 printf_unfiltered ("This can cause attach to "
1955 "fail on Windows NT/2K/XP\n");
1958 windows_init_thread_list ();
1959 ok
= DebugActiveProcess (pid
);
1965 /* Try fall back to Cygwin pid. */
1966 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1969 ok
= DebugActiveProcess (pid
);
1974 error (_("Can't attach to process."));
1976 DebugSetProcessKillOnExit (FALSE
);
1980 char *exec_file
= (char *) get_exec_file (0);
1983 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1984 target_pid_to_str (ptid_t (pid
)));
1986 printf_unfiltered ("Attaching to %s\n",
1987 target_pid_to_str (ptid_t (pid
)));
1989 gdb_flush (gdb_stdout
);
1992 do_initial_windows_stuff (this, pid
, 1);
1993 target_terminal::ours ();
1997 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2001 ptid_t ptid
= minus_one_ptid
;
2002 resume (ptid
, 0, GDB_SIGNAL_0
);
2004 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2006 error (_("Can't detach process %u (error %u)"),
2007 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2010 DebugSetProcessKillOnExit (FALSE
);
2012 if (detached
&& from_tty
)
2014 const char *exec_file
= get_exec_file (0);
2017 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2018 (unsigned) current_event
.dwProcessId
);
2019 gdb_flush (gdb_stdout
);
2022 x86_cleanup_dregs ();
2023 inferior_ptid
= null_ptid
;
2024 detach_inferior (inf
);
2026 maybe_unpush_target ();
2029 /* Try to determine the executable filename.
2031 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2033 Upon success, the filename is stored inside EXE_NAME_RET, and
2034 this function returns nonzero.
2036 Otherwise, this function returns zero and the contents of
2037 EXE_NAME_RET is undefined. */
2040 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2047 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2048 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2051 /* We know the executable is always first in the list of modules,
2052 which we just fetched. So no need to fetch more. */
2056 /* Cygwin prefers that the path be in /x/y/z format, so extract
2057 the filename into a temporary buffer first, and then convert it
2058 to POSIX format into the destination buffer. */
2059 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2061 len
= GetModuleFileNameEx (current_process_handle
,
2062 dh_buf
, pathbuf
, exe_name_max_len
);
2064 error (_("Error getting executable filename: %u."),
2065 (unsigned) GetLastError ());
2066 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2067 exe_name_max_len
) < 0)
2068 error (_("Error converting executable filename to POSIX: %d."), errno
);
2071 len
= GetModuleFileNameEx (current_process_handle
,
2072 dh_buf
, exe_name_ret
, exe_name_max_len
);
2074 error (_("Error getting executable filename: %u."),
2075 (unsigned) GetLastError ());
2078 return 1; /* success */
2081 /* The pid_to_exec_file target_ops method for this platform. */
2084 windows_nat_target::pid_to_exec_file (int pid
)
2086 static char path
[__PMAX
];
2088 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2090 char procexe
[sizeof ("/proc/4294967295/exe")];
2092 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2093 nchars
= readlink (procexe
, path
, sizeof(path
));
2094 if (nchars
> 0 && nchars
< sizeof (path
))
2096 path
[nchars
] = '\0'; /* Got it */
2101 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2102 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2103 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2109 /* Print status information about what we're accessing. */
2112 windows_nat_target::files_info ()
2114 struct inferior
*inf
= current_inferior ();
2116 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2117 inf
->attach_flag
? "attached" : "child",
2118 target_pid_to_str (inferior_ptid
));
2121 /* Modify CreateProcess parameters for use of a new separate console.
2123 *FLAGS: DWORD parameter for general process creation flags.
2124 *SI: STARTUPINFO structure, for which the console window size and
2125 console buffer size is filled in if GDB is running in a console.
2126 to create the new console.
2127 The size of the used font is not available on all versions of
2128 Windows OS. Furthermore, the current font might not be the default
2129 font, but this is still better than before.
2130 If the windows and buffer sizes are computed,
2131 SI->DWFLAGS is changed so that this information is used
2132 by CreateProcess function. */
2135 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2137 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2138 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2140 if (hconsole
!= INVALID_HANDLE_VALUE
)
2142 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2144 CONSOLE_FONT_INFO cfi
;
2146 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2147 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2148 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2149 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2150 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2152 si
->dwXSize
*= font_size
.X
;
2156 si
->dwYSize
*= font_size
.Y
;
2159 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2160 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2161 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2163 *flags
|= CREATE_NEW_CONSOLE
;
2167 /* Function called by qsort to sort environment strings. */
2170 envvar_cmp (const void *a
, const void *b
)
2172 const char **p
= (const char **) a
;
2173 const char **q
= (const char **) b
;
2174 return strcasecmp (*p
, *q
);
2180 clear_win32_environment (char **env
)
2184 wchar_t *copy
= NULL
, *equalpos
;
2186 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2188 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2189 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2190 mbstowcs (copy
, env
[i
], len
);
2191 equalpos
= wcschr (copy
, L
'=');
2194 SetEnvironmentVariableW (copy
, NULL
);
2202 /* Redirection of inferior I/O streams for native MS-Windows programs.
2203 Unlike on Unix, where this is handled by invoking the inferior via
2204 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2206 The official documentation of the cmd.exe redirection features is here:
2208 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2210 (That page talks about Windows XP, but there's no newer
2211 documentation, so we assume later versions of cmd.exe didn't change
2214 Caveat: the documentation on that page seems to include a few lies.
2215 For example, it describes strange constructs 1<&2 and 2<&1, which
2216 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2217 think the cmd.exe parser of the redirection symbols simply doesn't
2218 care about the < vs > distinction in these cases. Therefore, the
2219 supported features are explicitly documented below.
2221 The emulation below aims at supporting all the valid use cases
2222 supported by cmd.exe, which include:
2224 < FILE redirect standard input from FILE
2225 0< FILE redirect standard input from FILE
2226 <&N redirect standard input from file descriptor N
2227 0<&N redirect standard input from file descriptor N
2228 > FILE redirect standard output to FILE
2229 >> FILE append standard output to FILE
2230 1>> FILE append standard output to FILE
2231 >&N redirect standard output to file descriptor N
2232 1>&N redirect standard output to file descriptor N
2233 >>&N append standard output to file descriptor N
2234 1>>&N append standard output to file descriptor N
2235 2> FILE redirect standard error to FILE
2236 2>> FILE append standard error to FILE
2237 2>&N redirect standard error to file descriptor N
2238 2>>&N append standard error to file descriptor N
2240 Note that using N > 2 in the above construct is supported, but
2241 requires that the corresponding file descriptor be open by some
2242 means elsewhere or outside GDB. Also note that using ">&0" or
2243 "<&2" will generally fail, because the file descriptor redirected
2244 from is normally open in an incompatible mode (e.g., FD 0 is open
2245 for reading only). IOW, use of such tricks is not recommended;
2246 you are on your own.
2248 We do NOT support redirection of file descriptors above 2, as in
2249 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2250 that needs special handling in the startup code that MinGW
2251 doesn't have). Pipes are also not supported.
2253 As for invalid use cases, where the redirection contains some
2254 error, the emulation below will detect that and produce some
2255 error and/or failure. But the behavior in those cases is not
2256 bug-for-bug compatible with what cmd.exe does in those cases.
2257 That's because what cmd.exe does then is not well defined, and
2258 seems to be a side effect of the cmd.exe parsing of the command
2259 line more than anything else. For example, try redirecting to an
2260 invalid file name, as in "> foo:bar".
2262 There are also minor syntactic deviations from what cmd.exe does
2263 in some corner cases. For example, it doesn't support the likes
2264 of "> &foo" to mean redirect to file named literally "&foo"; we
2265 do support that here, because that, too, sounds like some issue
2266 with the cmd.exe parser. Another nicety is that we support
2267 redirection targets that use file names with forward slashes,
2268 something cmd.exe doesn't -- this comes in handy since GDB
2269 file-name completion can be used when typing the command line for
2272 /* Support routines for redirecting standard handles of the inferior. */
2274 /* Parse a single redirection spec, open/duplicate the specified
2275 file/fd, and assign the appropriate value to one of the 3 standard
2276 file descriptors. */
2278 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2280 int *fd
, ref_fd
= -2;
2282 const char *fname
= redir_string
+ 1;
2283 int rc
= *redir_string
;
2298 fd
= (rc
== '2') ? err
: out
;
2299 mode
= O_WRONLY
| O_CREAT
;
2312 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2314 /* A reference to a file descriptor. */
2316 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2317 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2319 /* Don't allow redirection when open modes are incompatible. */
2320 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2321 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2328 else if (ref_fd
== 1)
2330 else if (ref_fd
== 2)
2340 fname
++; /* skip the separator space */
2341 /* If the descriptor is already open, close it. This allows
2342 multiple specs of redirections for the same stream, which is
2343 somewhat nonsensical, but still valid and supported by cmd.exe.
2344 (But cmd.exe only opens a single file in this case, the one
2345 specified by the last redirection spec on the command line.) */
2350 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2354 else if (ref_fd
== -1)
2355 *fd
= -1; /* reset to default destination */
2358 *fd
= _dup (ref_fd
);
2362 /* _open just sets a flag for O_APPEND, which won't be passed to the
2363 inferior, so we need to actually move the file pointer. */
2364 if ((mode
& O_APPEND
) != 0)
2365 _lseek (*fd
, 0L, SEEK_END
);
2369 /* Canonicalize a single redirection spec and set up the corresponding
2370 file descriptor as specified. */
2372 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2374 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2376 const char *start
= s
;
2379 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2380 if ((*start
== '>' || *start
== '1' || *start
== '2')
2384 if (*s
== '>' && *start
!= '>')
2387 else if (*start
== '0' && *s
== '<')
2389 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2392 while (isspace (*s
)) /* skip whitespace before file name */
2394 *d
++ = ' '; /* separate file name with a single space */
2397 /* Copy the file name. */
2400 /* Remove quoting characters from the file name in buf[]. */
2401 if (*s
== '"') /* could support '..' quoting here */
2405 else if (*s
== quote
)
2413 else if (*s
== '\\')
2415 if (s
[1] == '"') /* could support '..' here */
2419 else if (isspace (*s
) && !quote
)
2423 if (d
- buf
>= sizeof (buf
) - 1)
2425 errno
= ENAMETOOLONG
;
2431 /* Windows doesn't allow redirection characters in file names, so we
2432 can bail out early if they use them, or if there's no target file
2433 name after the redirection symbol. */
2434 if (d
[-1] == '>' || d
[-1] == '<')
2439 if (redir_open (buf
, inp
, out
, err
) == 0)
2444 /* Parse the command line for redirection specs and prepare the file
2445 descriptors for the 3 standard streams accordingly. */
2447 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2448 int *inp
, int *out
, int *err
)
2450 const char *s
= cmd_orig
;
2453 bool retval
= false;
2455 while (isspace (*s
))
2460 if (*s
== '"') /* could also support '..' quoting here */
2464 else if (*s
== quote
)
2467 else if (*s
== '\\')
2469 if (s
[1] == '"') /* escaped quote char */
2474 /* Process a single redirection candidate. */
2475 if (*s
== '<' || *s
== '>'
2476 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2477 || (*s
== '0' && s
[1] == '<'))
2479 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2493 #endif /* !__CYGWIN__ */
2495 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2496 EXEC_FILE is the file to run.
2497 ALLARGS is a string containing the arguments to the program.
2498 ENV is the environment vector to pass. Errors reported with error(). */
2501 windows_nat_target::create_inferior (const char *exec_file
,
2502 const std::string
&origallargs
,
2503 char **in_env
, int from_tty
)
2507 cygwin_buf_t real_path
[__PMAX
];
2508 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2509 cygwin_buf_t infcwd
[__PMAX
];
2511 cygwin_buf_t
*toexec
;
2512 cygwin_buf_t
*cygallargs
;
2514 char **old_env
= NULL
;
2518 int ostdin
, ostdout
, ostderr
;
2519 #else /* !__CYGWIN__ */
2520 char shell
[__PMAX
]; /* Path to shell */
2522 char *args
, *allargs_copy
;
2523 size_t args_len
, allargs_len
;
2524 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2525 HANDLE tty
= INVALID_HANDLE_VALUE
;
2526 bool redirected
= false;
2533 #endif /* !__CYGWIN__ */
2534 const char *allargs
= origallargs
.c_str ();
2535 PROCESS_INFORMATION pi
;
2538 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2541 error (_("No executable specified, use `target exec'."));
2543 const char *inferior_cwd
= get_inferior_cwd ();
2544 std::string expanded_infcwd
;
2545 if (inferior_cwd
!= NULL
)
2547 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2548 /* Mirror slashes on inferior's cwd. */
2549 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2551 inferior_cwd
= expanded_infcwd
.c_str ();
2554 memset (&si
, 0, sizeof (si
));
2555 si
.cb
= sizeof (si
);
2558 flags
|= CREATE_NEW_PROCESS_GROUP
;
2561 windows_set_console_info (&si
, &flags
);
2566 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2567 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2568 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2569 error (_("Error starting executable: %d"), errno
);
2572 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2573 if (len
== (size_t) -1)
2574 error (_("Error starting executable: %d"), errno
);
2575 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2576 mbstowcs (cygallargs
, allargs
, len
);
2577 #else /* !__USEWIDE */
2578 cygallargs
= allargs
;
2583 sh
= getenv ("SHELL");
2586 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2587 error (_("Error starting executable via shell: %d"), errno
);
2589 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2590 + mbstowcs (NULL
, allargs
, 0) + 2;
2591 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2592 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2593 #else /* !__USEWIDE */
2594 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2595 + strlen (allargs
) + 2);
2596 cygallargs
= (char *) alloca (len
);
2597 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2598 #endif /* __USEWIDE */
2600 flags
|= DEBUG_PROCESS
;
2603 if (inferior_cwd
!= NULL
2604 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2605 infcwd
, strlen (inferior_cwd
)) < 0)
2606 error (_("Error converting inferior cwd: %d"), errno
);
2609 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2610 * sizeof (wchar_t));
2611 wcscpy (args
, toexec
);
2612 wcscat (args
, L
" ");
2613 wcscat (args
, cygallargs
);
2614 #else /* !__USEWIDE */
2615 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2616 strcpy (args
, toexec
);
2618 strcat (args
, cygallargs
);
2619 #endif /* !__USEWIDE */
2621 #ifdef CW_CVT_ENV_TO_WINENV
2622 /* First try to create a direct Win32 copy of the POSIX environment. */
2623 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2624 if (w32_env
!= (PWCHAR
) -1)
2625 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2627 /* If that fails, fall back to old method tweaking GDB's environment. */
2628 #endif /* CW_CVT_ENV_TO_WINENV */
2630 /* Reset all Win32 environment variables to avoid leftover on next run. */
2631 clear_win32_environment (environ
);
2632 /* Prepare the environment vars for CreateProcess. */
2635 cygwin_internal (CW_SYNC_WINENV
);
2639 if (!inferior_io_terminal
)
2640 tty
= ostdin
= ostdout
= ostderr
= -1;
2643 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2646 print_sys_errmsg (inferior_io_terminal
, errno
);
2647 ostdin
= ostdout
= ostderr
= -1;
2660 windows_init_thread_list ();
2661 ret
= CreateProcess (0,
2662 args
, /* command line */
2663 NULL
, /* Security */
2665 TRUE
, /* inherit handles */
2666 flags
, /* start flags */
2667 w32_env
, /* environment */
2668 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2673 /* Just free the Win32 environment, if it could be created. */
2677 /* Reset all environment variables to avoid leftover on next run. */
2678 clear_win32_environment (in_env
);
2679 /* Restore normal GDB environment variables. */
2681 cygwin_internal (CW_SYNC_WINENV
);
2694 #else /* !__CYGWIN__ */
2695 allargs_len
= strlen (allargs
);
2696 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2697 if (strpbrk (allargs_copy
, "<>") != NULL
)
2702 redirect_inferior_handles (allargs
, allargs_copy
,
2703 &fd_inp
, &fd_out
, &fd_err
);
2705 warning (_("Error in redirection: %s."), strerror (errno
));
2708 allargs_len
= strlen (allargs_copy
);
2710 /* If not all the standard streams are redirected by the command
2711 line, use inferior_io_terminal for those which aren't. */
2712 if (inferior_io_terminal
2713 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2715 SECURITY_ATTRIBUTES sa
;
2716 sa
.nLength
= sizeof(sa
);
2717 sa
.lpSecurityDescriptor
= 0;
2718 sa
.bInheritHandle
= TRUE
;
2719 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2720 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2721 if (tty
== INVALID_HANDLE_VALUE
)
2722 warning (_("Warning: Failed to open TTY %s, error %#x."),
2723 inferior_io_terminal
, (unsigned) GetLastError ());
2725 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2728 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2729 else if (tty
!= INVALID_HANDLE_VALUE
)
2732 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2734 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2735 else if (tty
!= INVALID_HANDLE_VALUE
)
2736 si
.hStdOutput
= tty
;
2738 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2740 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2741 else if (tty
!= INVALID_HANDLE_VALUE
)
2744 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2745 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2749 /* Build the command line, a space-separated list of tokens where
2750 the first token is the name of the module to be executed.
2751 To avoid ambiguities introduced by spaces in the module name,
2753 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2754 args
= (char *) alloca (args_len
);
2755 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2757 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2759 /* CreateProcess takes the environment list as a null terminated set of
2760 strings (i.e. two nulls terminate the list). */
2762 /* Get total size for env strings. */
2763 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2764 envlen
+= strlen (in_env
[i
]) + 1;
2766 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2767 env
= (char **) alloca (envsize
);
2768 memcpy (env
, in_env
, envsize
);
2769 /* Windows programs expect the environment block to be sorted. */
2770 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2772 w32env
= (char *) alloca (envlen
+ 1);
2774 /* Copy env strings into new buffer. */
2775 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2777 strcpy (temp
, env
[i
]);
2778 temp
+= strlen (temp
) + 1;
2781 /* Final nil string to terminate new env. */
2784 windows_init_thread_list ();
2785 ret
= CreateProcessA (0,
2786 args
, /* command line */
2787 NULL
, /* Security */
2789 TRUE
, /* inherit handles */
2790 flags
, /* start flags */
2791 w32env
, /* environment */
2792 inferior_cwd
, /* current directory */
2795 if (tty
!= INVALID_HANDLE_VALUE
)
2803 #endif /* !__CYGWIN__ */
2806 error (_("Error creating process %s, (error %u)."),
2807 exec_file
, (unsigned) GetLastError ());
2809 CloseHandle (pi
.hThread
);
2810 CloseHandle (pi
.hProcess
);
2812 if (useshell
&& shell
[0] != '\0')
2817 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2819 /* windows_continue (DBG_CONTINUE, -1, 0); */
2823 windows_nat_target::mourn_inferior ()
2825 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2826 x86_cleanup_dregs();
2827 if (open_process_used
)
2829 CHECK (CloseHandle (current_process_handle
));
2830 open_process_used
= 0;
2832 inf_child_target::mourn_inferior ();
2835 /* Send a SIGINT to the process group. This acts just like the user typed a
2836 ^C on the controlling terminal. */
2839 windows_nat_target::interrupt ()
2841 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2842 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2843 registers_changed (); /* refresh register state */
2846 /* Helper for windows_xfer_partial that handles memory transfers.
2847 Arguments are like target_xfer_partial. */
2849 static enum target_xfer_status
2850 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2851 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2855 DWORD lasterror
= 0;
2857 if (writebuf
!= NULL
)
2859 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2860 pulongest (len
), core_addr_to_string (memaddr
)));
2861 success
= WriteProcessMemory (current_process_handle
,
2862 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2865 lasterror
= GetLastError ();
2866 FlushInstructionCache (current_process_handle
,
2867 (LPCVOID
) (uintptr_t) memaddr
, len
);
2871 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2872 pulongest (len
), core_addr_to_string (memaddr
)));
2873 success
= ReadProcessMemory (current_process_handle
,
2874 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2877 lasterror
= GetLastError ();
2879 *xfered_len
= (ULONGEST
) done
;
2880 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2881 return TARGET_XFER_OK
;
2883 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2887 windows_nat_target::kill ()
2889 CHECK (TerminateProcess (current_process_handle
, 0));
2893 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2895 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2897 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2901 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2905 windows_nat_target::close ()
2907 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2908 inferior_ptid
.pid ()));
2911 /* Convert pid to printable format. */
2913 windows_nat_target::pid_to_str (ptid_t ptid
)
2915 static char buf
[80];
2917 if (ptid
.tid () != 0)
2919 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2920 ptid
.pid (), ptid
.tid ());
2924 return normal_pid_to_str (ptid
);
2927 static enum target_xfer_status
2928 windows_xfer_shared_libraries (struct target_ops
*ops
,
2929 enum target_object object
, const char *annex
,
2930 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2931 ULONGEST offset
, ULONGEST len
,
2932 ULONGEST
*xfered_len
)
2934 struct obstack obstack
;
2940 return TARGET_XFER_E_IO
;
2942 obstack_init (&obstack
);
2943 obstack_grow_str (&obstack
, "<library-list>\n");
2944 for (so
= solib_start
.next
; so
; so
= so
->next
)
2946 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2948 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2949 (uintptr_t) li
->load_addr
,
2950 target_gdbarch (), &obstack
);
2952 obstack_grow_str0 (&obstack
, "</library-list>\n");
2954 buf
= (const char *) obstack_finish (&obstack
);
2955 len_avail
= strlen (buf
);
2956 if (offset
>= len_avail
)
2960 if (len
> len_avail
- offset
)
2961 len
= len_avail
- offset
;
2962 memcpy (readbuf
, buf
+ offset
, len
);
2965 obstack_free (&obstack
, NULL
);
2966 *xfered_len
= (ULONGEST
) len
;
2967 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2970 enum target_xfer_status
2971 windows_nat_target::xfer_partial (enum target_object object
,
2972 const char *annex
, gdb_byte
*readbuf
,
2973 const gdb_byte
*writebuf
, ULONGEST offset
,
2974 ULONGEST len
, ULONGEST
*xfered_len
)
2978 case TARGET_OBJECT_MEMORY
:
2979 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2981 case TARGET_OBJECT_LIBRARIES
:
2982 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2983 writebuf
, offset
, len
, xfered_len
);
2986 if (beneath () == NULL
)
2988 /* This can happen when requesting the transfer of unsupported
2989 objects before a program has been started (and therefore
2990 with the current_target having no target beneath). */
2991 return TARGET_XFER_E_IO
;
2993 return beneath ()->xfer_partial (object
, annex
,
2994 readbuf
, writebuf
, offset
, len
,
2999 /* Provide thread local base, i.e. Thread Information Block address.
3000 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3003 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3005 windows_thread_info
*th
;
3007 th
= thread_rec (ptid
.tid (), 0);
3012 *addr
= th
->thread_local_base
;
3018 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3020 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3023 /* Implementation of the to_thread_name method. */
3026 windows_nat_target::thread_name (struct thread_info
*thr
)
3028 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3033 _initialize_windows_nat (void)
3035 x86_dr_low
.set_control
= cygwin_set_dr7
;
3036 x86_dr_low
.set_addr
= cygwin_set_dr
;
3037 x86_dr_low
.get_addr
= cygwin_get_dr
;
3038 x86_dr_low
.get_status
= cygwin_get_dr6
;
3039 x86_dr_low
.get_control
= cygwin_get_dr7
;
3041 /* x86_dr_low.debug_register_length field is set by
3042 calling x86_set_debug_register_length function
3043 in processor windows specific native file. */
3045 add_inf_child_target (&the_windows_nat_target
);
3048 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3051 add_com ("signal-event", class_run
, signal_event_command
, _("\
3052 Signal a crashed process with event ID, to allow its debugging.\n\
3053 This command is needed in support of setting up GDB as JIT debugger on \
3054 MS-Windows. The command should be invoked from the GDB command line using \
3055 the '-ex' command-line option. The ID of the event that blocks the \
3056 crashed process will be supplied by the Windows JIT debugging mechanism."));
3059 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3060 Set use of shell to start subprocess."), _("\
3061 Show use of shell to start subprocess."), NULL
,
3063 NULL
, /* FIXME: i18n: */
3064 &setlist
, &showlist
);
3066 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3067 &cygwin_exceptions
, _("\
3068 Break when an exception is detected in the Cygwin DLL itself."), _("\
3069 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3071 NULL
, /* FIXME: i18n: */
3072 &setlist
, &showlist
);
3075 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3076 Set creation of new console when creating child process."), _("\
3077 Show creation of new console when creating child process."), NULL
,
3079 NULL
, /* FIXME: i18n: */
3080 &setlist
, &showlist
);
3082 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3083 Set creation of new group when creating child process."), _("\
3084 Show creation of new group when creating child process."), NULL
,
3086 NULL
, /* FIXME: i18n: */
3087 &setlist
, &showlist
);
3089 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3090 Set whether to display execution in child process."), _("\
3091 Show whether to display execution in child process."), NULL
,
3093 NULL
, /* FIXME: i18n: */
3094 &setlist
, &showlist
);
3096 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3097 Set whether to display kernel events in child process."), _("\
3098 Show whether to display kernel events in child process."), NULL
,
3100 NULL
, /* FIXME: i18n: */
3101 &setlist
, &showlist
);
3103 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3104 Set whether to display memory accesses in child process."), _("\
3105 Show whether to display memory accesses in child process."), NULL
,
3107 NULL
, /* FIXME: i18n: */
3108 &setlist
, &showlist
);
3110 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3111 &debug_exceptions
, _("\
3112 Set whether to display kernel exceptions in child process."), _("\
3113 Show whether to display kernel exceptions in child process."), NULL
,
3115 NULL
, /* FIXME: i18n: */
3116 &setlist
, &showlist
);
3118 init_w32_command_list ();
3120 add_cmd ("selector", class_info
, display_selectors
,
3121 _("Display selectors infos."),
3125 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3127 /* Pass the address ADDR to the inferior in the I'th debug register.
3128 Here we just store the address in dr array, the registers will be
3129 actually set up when windows_continue is called. */
3131 cygwin_set_dr (int i
, CORE_ADDR addr
)
3134 internal_error (__FILE__
, __LINE__
,
3135 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3137 debug_registers_changed
= 1;
3138 debug_registers_used
= 1;
3141 /* Pass the value VAL to the inferior in the DR7 debug control
3142 register. Here we just store the address in D_REGS, the watchpoint
3143 will be actually set up in windows_wait. */
3145 cygwin_set_dr7 (unsigned long val
)
3147 dr
[7] = (CORE_ADDR
) val
;
3148 debug_registers_changed
= 1;
3149 debug_registers_used
= 1;
3152 /* Get the value of debug register I from the inferior. */
3155 cygwin_get_dr (int i
)
3160 /* Get the value of the DR6 debug status register from the inferior.
3161 Here we just return the value stored in dr[6]
3162 by the last call to thread_rec for current_event.dwThreadId id. */
3163 static unsigned long
3164 cygwin_get_dr6 (void)
3166 return (unsigned long) dr
[6];
3169 /* Get the value of the DR7 debug status register from the inferior.
3170 Here we just return the value stored in dr[7] by the last call to
3171 thread_rec for current_event.dwThreadId id. */
3173 static unsigned long
3174 cygwin_get_dr7 (void)
3176 return (unsigned long) dr
[7];
3179 /* Determine if the thread referenced by "ptid" is alive
3180 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3181 it means that the thread has died. Otherwise it is assumed to be alive. */
3184 windows_nat_target::thread_alive (ptid_t ptid
)
3188 gdb_assert (ptid
.tid () != 0);
3191 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3195 _initialize_check_for_gdb_ini (void)
3198 if (inhibit_gdbinit
)
3201 homedir
= getenv ("HOME");
3205 char *oldini
= (char *) alloca (strlen (homedir
) +
3206 sizeof ("gdb.ini") + 1);
3207 strcpy (oldini
, homedir
);
3208 p
= strchr (oldini
, '\0');
3209 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3211 strcpy (p
, "gdb.ini");
3212 if (access (oldini
, 0) == 0)
3214 int len
= strlen (oldini
);
3215 char *newini
= (char *) alloca (len
+ 2);
3217 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3218 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3219 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3224 /* Define dummy functions which always return error for the rare cases where
3225 these functions could not be found. */
3227 bad_DebugActiveProcessStop (DWORD w
)
3232 bad_DebugBreakProcess (HANDLE w
)
3237 bad_DebugSetProcessKillOnExit (BOOL w
)
3242 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3249 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3255 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3262 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3268 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3274 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3280 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3288 /* Load any functions which may not be available in ancient versions
3292 _initialize_loadable (void)
3296 #define GPA(m, func) \
3297 func = (func ## _ftype *) GetProcAddress (m, #func)
3299 hm
= LoadLibrary ("kernel32.dll");
3302 GPA (hm
, DebugActiveProcessStop
);
3303 GPA (hm
, DebugBreakProcess
);
3304 GPA (hm
, DebugSetProcessKillOnExit
);
3305 GPA (hm
, GetConsoleFontSize
);
3306 GPA (hm
, DebugActiveProcessStop
);
3307 GPA (hm
, GetCurrentConsoleFont
);
3310 /* Set variables to dummy versions of these processes if the function
3311 wasn't found in kernel32.dll. */
3312 if (!DebugBreakProcess
)
3313 DebugBreakProcess
= bad_DebugBreakProcess
;
3314 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3316 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3317 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3319 if (!GetConsoleFontSize
)
3320 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3321 if (!GetCurrentConsoleFont
)
3322 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3324 /* Load optional functions used for retrieving filename information
3325 associated with the currently debugged process or its dlls. */
3326 hm
= LoadLibrary ("psapi.dll");
3329 GPA (hm
, EnumProcessModules
);
3330 GPA (hm
, GetModuleInformation
);
3331 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3332 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3335 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3337 /* Set variables to dummy versions of these processes if the function
3338 wasn't found in psapi.dll. */
3339 EnumProcessModules
= bad_EnumProcessModules
;
3340 GetModuleInformation
= bad_GetModuleInformation
;
3341 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3342 /* This will probably fail on Windows 9x/Me. Let the user know
3343 that we're missing some functionality. */
3345 cannot automatically find executable file or library to read symbols.\n\
3346 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3349 hm
= LoadLibrary ("advapi32.dll");
3352 GPA (hm
, OpenProcessToken
);
3353 GPA (hm
, LookupPrivilegeValueA
);
3354 GPA (hm
, AdjustTokenPrivileges
);
3355 /* Only need to set one of these since if OpenProcessToken fails nothing
3357 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3358 || !AdjustTokenPrivileges
)
3359 OpenProcessToken
= bad_OpenProcessToken
;