1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2019 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 "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
68 #include "inf-child.h"
69 #include "gdbsupport/gdb_tilde_expand.h"
70 #include "gdbsupport/pathstuff.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 */
240 /* Counts of things. */
241 static int exception_count
= 0;
242 static int event_count
= 0;
243 static int saw_create
;
244 static int open_process_used
= 0;
247 static bool new_console
= false;
249 static bool cygwin_exceptions
= false;
251 static bool new_group
= true;
252 static bool debug_exec
= false; /* show execution */
253 static bool debug_events
= false; /* show events from kernel */
254 static bool debug_memory
= false; /* show target memory accesses */
255 static bool debug_exceptions
= false; /* show target exceptions */
256 static bool useshell
= false; /* use shell for subprocesses */
258 /* This vector maps GDB's idea of a register's number into an offset
259 in the windows exception context vector.
261 It also contains the bit mask needed to load the register in question.
263 The contents of this table can only be computed by the units
264 that provide CPU-specific support for Windows native debugging.
265 These units should set the table by calling
266 windows_set_context_register_offsets.
268 One day we could read a reg, we could inspect the context we
269 already have loaded, if it doesn't have the bit set that we need,
270 we read that set of registers in using GetThreadContext. If the
271 context already contains what we need, we just unpack it. Then to
272 write a register, first we have to ensure that the context contains
273 the other regs of the group, and then we copy the info in and set
276 static const int *mappings
;
278 /* The function to use in order to determine whether a register is
279 a segment register or not. */
280 static segment_register_p_ftype
*segment_register_p
;
282 /* See windows_nat_target::resume to understand why this is commented
285 /* This vector maps the target's idea of an exception (extracted
286 from the DEBUG_EVENT structure) to GDB's idea. */
288 struct xlate_exception
294 static const struct xlate_exception xlate
[] =
296 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
297 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
298 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
299 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
300 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
301 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
}
306 struct windows_nat_target final
: public x86_nat_target
<inf_child_target
>
308 void close () override
;
310 void attach (const char *, int) override
;
312 bool attach_no_wait () override
315 void detach (inferior
*, int) override
;
317 void resume (ptid_t
, int , enum gdb_signal
) override
;
319 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
321 void fetch_registers (struct regcache
*, int) override
;
322 void store_registers (struct regcache
*, int) override
;
324 enum target_xfer_status
xfer_partial (enum target_object object
,
327 const gdb_byte
*writebuf
,
328 ULONGEST offset
, ULONGEST len
,
329 ULONGEST
*xfered_len
) override
;
331 void files_info () override
;
333 void kill () override
;
335 void create_inferior (const char *, const std::string
&,
336 char **, int) override
;
338 void mourn_inferior () override
;
340 bool thread_alive (ptid_t ptid
) override
;
342 std::string
pid_to_str (ptid_t
) override
;
344 void interrupt () override
;
346 char *pid_to_exec_file (int pid
) override
;
348 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
350 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
352 const char *thread_name (struct thread_info
*) override
;
355 static windows_nat_target the_windows_nat_target
;
357 /* Set the MAPPINGS static global to OFFSETS.
358 See the description of MAPPINGS for more details. */
361 windows_set_context_register_offsets (const int *offsets
)
366 /* See windows-nat.h. */
369 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
371 segment_register_p
= fun
;
375 check (BOOL ok
, const char *file
, int line
)
378 printf_filtered ("error return %s:%d was %u\n", file
, line
,
379 (unsigned) GetLastError ());
382 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
383 then also retrieve the context for this thread. If GET_CONTEXT is
384 negative, then don't suspend the thread. */
385 static windows_thread_info
*
386 thread_rec (DWORD id
, int get_context
)
388 windows_thread_info
*th
;
390 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
393 if (!th
->suspended
&& get_context
)
395 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
397 if (SuspendThread (th
->h
) == (DWORD
) -1)
399 DWORD err
= GetLastError ();
401 /* We get Access Denied (5) when trying to suspend
402 threads that Windows started on behalf of the
403 debuggee, usually when those threads are just
405 We can get Invalid Handle (6) if the main thread
407 if (err
!= ERROR_INVALID_HANDLE
408 && err
!= ERROR_ACCESS_DENIED
)
409 warning (_("SuspendThread (tid=0x%x) failed."
411 (unsigned) id
, (unsigned) err
);
417 else if (get_context
< 0)
419 th
->reload_context
= 1;
427 /* Add a thread to the thread list.
429 PTID is the ptid of the thread to be added.
430 H is its Windows handle.
431 TLB is its thread local base.
432 MAIN_THREAD_P should be true if the thread to be added is
433 the main thread, false otherwise. */
435 static windows_thread_info
*
436 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
438 windows_thread_info
*th
;
441 gdb_assert (ptid
.tid () != 0);
445 if ((th
= thread_rec (id
, FALSE
)))
448 th
= XCNEW (windows_thread_info
);
451 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
452 th
->next
= thread_head
.next
;
453 thread_head
.next
= th
;
455 /* Add this new thread to the list of threads.
457 To be consistent with what's done on other platforms, we add
458 the main thread silently (in reality, this thread is really
459 more of a process to the user than a thread). */
461 add_thread_silent (ptid
);
465 /* Set the debug registers for the new thread if they are used. */
466 if (debug_registers_used
)
468 /* Only change the value of the debug registers. */
469 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
470 CHECK (GetThreadContext (th
->h
, &th
->context
));
471 th
->context
.Dr0
= dr
[0];
472 th
->context
.Dr1
= dr
[1];
473 th
->context
.Dr2
= dr
[2];
474 th
->context
.Dr3
= dr
[3];
475 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
476 th
->context
.Dr7
= dr
[7];
477 CHECK (SetThreadContext (th
->h
, &th
->context
));
478 th
->context
.ContextFlags
= 0;
483 /* Clear out any old thread list and reinitialize it to a
486 windows_init_thread_list (void)
488 windows_thread_info
*th
= &thread_head
;
490 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
492 while (th
->next
!= NULL
)
494 windows_thread_info
*here
= th
->next
;
495 th
->next
= here
->next
;
498 thread_head
.next
= NULL
;
501 /* Delete a thread from the list of threads.
503 PTID is the ptid of the thread to be deleted.
504 EXIT_CODE is the thread's exit code.
505 MAIN_THREAD_P should be true if the thread to be deleted is
506 the main thread, false otherwise. */
509 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
511 windows_thread_info
*th
;
514 gdb_assert (ptid
.tid () != 0);
518 /* Emit a notification about the thread being deleted.
520 Note that no notification was printed when the main thread
521 was created, and thus, unless in verbose mode, we should be
522 symetrical, and avoid that notification for the main thread
526 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
527 else if (print_thread_events
&& !main_thread_p
)
528 printf_unfiltered (_("[%s exited with code %u]\n"),
529 target_pid_to_str (ptid
).c_str (),
530 (unsigned) exit_code
);
532 delete_thread (find_thread_ptid (ptid
));
534 for (th
= &thread_head
;
535 th
->next
!= NULL
&& th
->next
->id
!= id
;
539 if (th
->next
!= NULL
)
541 windows_thread_info
*here
= th
->next
;
542 th
->next
= here
->next
;
548 /* Fetches register number R from the given windows_thread_info,
549 and supplies its value to the given regcache.
551 This function assumes that R is non-negative. A failed assertion
552 is raised if that is not true.
554 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
555 that the windows_thread_info has an up-to-date context. A failed
556 assertion is raised if that assumption is violated. */
559 windows_fetch_one_register (struct regcache
*regcache
,
560 windows_thread_info
*th
, int r
)
563 gdb_assert (!th
->reload_context
);
565 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
566 struct gdbarch
*gdbarch
= regcache
->arch ();
567 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
569 if (r
== I387_FISEG_REGNUM (tdep
))
571 long l
= *((long *) context_offset
) & 0xffff;
572 regcache
->raw_supply (r
, (char *) &l
);
574 else if (r
== I387_FOP_REGNUM (tdep
))
576 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
577 regcache
->raw_supply (r
, (char *) &l
);
579 else if (segment_register_p (r
))
581 /* GDB treats segment registers as 32bit registers, but they are
582 in fact only 16 bits long. Make sure we do not read extra
583 bits from our source buffer. */
584 long l
= *((long *) context_offset
) & 0xffff;
585 regcache
->raw_supply (r
, (char *) &l
);
588 regcache
->raw_supply (r
, context_offset
);
592 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
594 DWORD pid
= regcache
->ptid ().tid ();
595 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
597 /* Check if TH exists. Windows sometimes uses a non-existent
598 thread id in its events. */
602 if (th
->reload_context
)
605 if (have_saved_context
)
607 /* Lie about where the program actually is stopped since
608 cygwin has informed us that we should consider the signal
609 to have occurred at another location which is stored in
611 memcpy (&th
->context
, &saved_context
,
612 __COPY_CONTEXT_SIZE
);
613 have_saved_context
= 0;
618 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
619 CHECK (GetThreadContext (th
->h
, &th
->context
));
620 /* Copy dr values from that thread.
621 But only if there were not modified since last stop.
623 if (!debug_registers_changed
)
625 dr
[0] = th
->context
.Dr0
;
626 dr
[1] = th
->context
.Dr1
;
627 dr
[2] = th
->context
.Dr2
;
628 dr
[3] = th
->context
.Dr3
;
629 dr
[6] = th
->context
.Dr6
;
630 dr
[7] = th
->context
.Dr7
;
633 th
->reload_context
= 0;
637 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
638 windows_fetch_one_register (regcache
, th
, r
);
640 windows_fetch_one_register (regcache
, th
, r
);
643 /* Collect the register number R from the given regcache, and store
644 its value into the corresponding area of the given thread's context.
646 This function assumes that R is non-negative. A failed assertion
647 assertion is raised if that is not true. */
650 windows_store_one_register (const struct regcache
*regcache
,
651 windows_thread_info
*th
, int r
)
655 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
658 /* Store a new register value into the context of the thread tied to
662 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
664 DWORD pid
= regcache
->ptid ().tid ();
665 windows_thread_info
*th
= thread_rec (pid
, TRUE
);
667 /* Check if TH exists. Windows sometimes uses a non-existent
668 thread id in its events. */
673 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
674 windows_store_one_register (regcache
, th
, r
);
676 windows_store_one_register (regcache
, th
, r
);
679 /* Encapsulate the information required in a call to
680 symbol_file_add_args. */
681 struct safe_symbol_file_add_args
685 section_addr_info
*addrs
;
688 struct ui_file
*err
, *out
;
692 /* Maintain a linked list of "so" information. */
693 struct lm_info_windows
: public lm_info_base
695 LPVOID load_addr
= 0;
698 static struct so_list solib_start
, *solib_end
;
700 static struct so_list
*
701 windows_make_so (const char *name
, LPVOID load_addr
)
708 WIN32_FIND_DATA w32_fd
;
709 HANDLE h
= FindFirstFile(name
, &w32_fd
);
711 if (h
== INVALID_HANDLE_VALUE
)
717 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
719 p
= strrchr (buf
, '\\');
722 SetCurrentDirectory (buf
);
723 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
724 SetCurrentDirectory (cwd
);
727 if (strcasecmp (buf
, "ntdll.dll") == 0)
729 GetSystemDirectory (buf
, sizeof (buf
));
730 strcat (buf
, "\\ntdll.dll");
733 cygwin_buf_t buf
[__PMAX
];
736 if (access (name
, F_OK
) != 0)
738 if (strcasecmp (name
, "ntdll.dll") == 0)
741 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
742 wcscat (buf
, L
"\\ntdll.dll");
746 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
747 strcat (buf
, "\\ntdll.dll");
752 so
= XCNEW (struct so_list
);
753 lm_info_windows
*li
= new lm_info_windows
;
755 li
->load_addr
= load_addr
;
756 strcpy (so
->so_original_name
, name
);
758 strcpy (so
->so_name
, buf
);
761 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
762 SO_NAME_MAX_PATH_SIZE
);
765 char *rname
= realpath (name
, NULL
);
766 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
768 strcpy (so
->so_name
, rname
);
772 error (_("dll path too long"));
774 /* Record cygwin1.dll .text start/end. */
775 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
776 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
778 asection
*text
= NULL
;
780 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
785 if (bfd_check_format (abfd
.get (), bfd_object
))
786 text
= bfd_get_section_by_name (abfd
.get (), ".text");
791 /* The symbols in a dll are offset by 0x1000, which is the
792 offset from 0 of the first byte in an image - because of the
793 file header and the section alignment. */
794 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
796 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
804 get_image_name (HANDLE h
, void *address
, int unicode
)
807 static char buf
[__PMAX
];
809 static char buf
[(2 * __PMAX
) + 1];
811 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
817 /* Attempt to read the name of the dll that was detected.
818 This is documented to work only when actively debugging
819 a program. It will not work for attached processes. */
823 /* See if we could read the address of a string, and that the
824 address isn't null. */
825 if (!ReadProcessMemory (h
, address
, &address_ptr
,
826 sizeof (address_ptr
), &done
)
827 || done
!= sizeof (address_ptr
) || !address_ptr
)
830 /* Find the length of the string. */
831 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
832 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
836 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
839 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
840 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
843 wcstombs (buf
, unicode_address
, __PMAX
);
845 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
853 /* Handle a DLL load event, and return 1.
855 This function assumes that this event did not occur during inferior
856 initialization, where their event info may be incomplete (see
857 do_initial_windows_stuff and windows_add_all_dlls for more info
858 on how we handle DLL loading during that phase). */
863 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
866 /* Try getting the DLL name via the lpImageName field of the event.
867 Note that Microsoft documents this fields as strictly optional,
868 in the sense that it might be NULL. And the first DLL event in
869 particular is explicitly documented as "likely not pass[ed]"
870 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
871 dll_name
= get_image_name (current_process_handle
,
872 event
->lpImageName
, event
->fUnicode
);
876 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
877 solib_end
= solib_end
->next
;
879 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
881 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
882 host_address_to_string (li
->load_addr
)));
886 windows_free_so (struct so_list
*so
)
888 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
894 /* Handle a DLL unload event.
895 Return 1 if successful, or zero otherwise.
897 This function assumes that this event did not occur during inferior
898 initialization, where their event info may be incomplete (see
899 do_initial_windows_stuff and windows_add_all_dlls for more info
900 on how we handle DLL loading during that phase). */
905 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
908 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
910 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
912 if (li_next
->load_addr
== lpBaseOfDll
)
914 struct so_list
*sodel
= so
->next
;
916 so
->next
= sodel
->next
;
919 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
921 windows_free_so (sodel
);
926 /* We did not find any DLL that was previously loaded at this address,
927 so register a complaint. We do not report an error, because we have
928 observed that this may be happening under some circumstances. For
929 instance, running 32bit applications on x64 Windows causes us to receive
930 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
931 events are apparently caused by the WOW layer, the interface between
932 32bit and 64bit worlds). */
933 complaint (_("dll starting at %s not found."),
934 host_address_to_string (lpBaseOfDll
));
937 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
941 catch_errors (void (*func
) ())
947 catch (const gdb_exception
&ex
)
949 exception_print (gdb_stderr
, ex
);
953 /* Clear list of loaded DLLs. */
955 windows_clear_solib (void)
957 solib_start
.next
= NULL
;
958 solib_end
= &solib_start
;
962 signal_event_command (const char *args
, int from_tty
)
964 uintptr_t event_id
= 0;
965 char *endargs
= NULL
;
968 error (_("signal-event requires an argument (integer event id)"));
970 event_id
= strtoumax (args
, &endargs
, 10);
972 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
973 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
974 error (_("Failed to convert `%s' to event id"), args
);
976 SetEvent ((HANDLE
) event_id
);
977 CloseHandle ((HANDLE
) event_id
);
980 /* Handle DEBUG_STRING output from child process.
981 Cygwin prepends its messages with a "cygwin:". Interpret this as
982 a Cygwin signal. Otherwise just print the string as a warning. */
984 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
986 gdb::unique_xmalloc_ptr
<char> s
;
989 if (!target_read_string
990 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
992 || !s
|| !*(s
.get ()))
994 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
997 if (!startswith (s
.get (), "cYg"))
1000 char *p
= strchr (s
.get (), '\0');
1002 if (p
> s
.get () && *--p
== '\n')
1004 warning (("%s"), s
.get ());
1010 /* Got a cygwin signal marker. A cygwin signal is followed by
1011 the signal number itself and then optionally followed by the
1012 thread id and address to saved context within the DLL. If
1013 these are supplied, then the given thread is assumed to have
1014 issued the signal and the context from the thread is assumed
1015 to be stored at the given address in the inferior. Tell gdb
1016 to treat this like a real signal. */
1018 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1019 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1021 ourstatus
->value
.sig
= gotasig
;
1027 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1028 retval
= strtoul (p
, &p
, 0);
1030 retval
= current_event
.dwThreadId
;
1031 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1032 && ReadProcessMemory (current_process_handle
, x
,
1034 __COPY_CONTEXT_SIZE
, &n
)
1035 && n
== __COPY_CONTEXT_SIZE
)
1036 have_saved_context
= 1;
1045 display_selector (HANDLE thread
, DWORD sel
)
1048 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1051 printf_filtered ("0x%03x: ", (unsigned) sel
);
1052 if (!info
.HighWord
.Bits
.Pres
)
1054 puts_filtered ("Segment not present\n");
1057 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1058 (info
.HighWord
.Bits
.BaseMid
<< 16)
1060 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1061 if (info
.HighWord
.Bits
.Granularity
)
1062 limit
= (limit
<< 12) | 0xfff;
1063 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1064 if (info
.HighWord
.Bits
.Default_Big
)
1065 puts_filtered(" 32-bit ");
1067 puts_filtered(" 16-bit ");
1068 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1071 puts_filtered ("Data (Read-Only, Exp-up");
1074 puts_filtered ("Data (Read/Write, Exp-up");
1077 puts_filtered ("Unused segment (");
1080 puts_filtered ("Data (Read/Write, Exp-down");
1083 puts_filtered ("Code (Exec-Only, N.Conf");
1086 puts_filtered ("Code (Exec/Read, N.Conf");
1089 puts_filtered ("Code (Exec-Only, Conf");
1092 puts_filtered ("Code (Exec/Read, Conf");
1095 printf_filtered ("Unknown type 0x%lx",
1096 (unsigned long) info
.HighWord
.Bits
.Type
);
1098 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1099 puts_filtered(", N.Acc");
1100 puts_filtered (")\n");
1101 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1102 puts_filtered("System selector ");
1103 printf_filtered ("Priviledge level = %ld. ",
1104 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1105 if (info
.HighWord
.Bits
.Granularity
)
1106 puts_filtered ("Page granular.\n");
1108 puts_filtered ("Byte granular.\n");
1113 DWORD err
= GetLastError ();
1114 if (err
== ERROR_NOT_SUPPORTED
)
1115 printf_filtered ("Function not supported\n");
1117 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1123 display_selectors (const char * args
, int from_tty
)
1125 if (!current_thread
)
1127 puts_filtered ("Impossible to display selectors now.\n");
1133 puts_filtered ("Selector $cs\n");
1134 display_selector (current_thread
->h
,
1135 current_thread
->context
.SegCs
);
1136 puts_filtered ("Selector $ds\n");
1137 display_selector (current_thread
->h
,
1138 current_thread
->context
.SegDs
);
1139 puts_filtered ("Selector $es\n");
1140 display_selector (current_thread
->h
,
1141 current_thread
->context
.SegEs
);
1142 puts_filtered ("Selector $ss\n");
1143 display_selector (current_thread
->h
,
1144 current_thread
->context
.SegSs
);
1145 puts_filtered ("Selector $fs\n");
1146 display_selector (current_thread
->h
,
1147 current_thread
->context
.SegFs
);
1148 puts_filtered ("Selector $gs\n");
1149 display_selector (current_thread
->h
,
1150 current_thread
->context
.SegGs
);
1155 sel
= parse_and_eval_long (args
);
1156 printf_filtered ("Selector \"%s\"\n",args
);
1157 display_selector (current_thread
->h
, sel
);
1161 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1162 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1163 host_address_to_string (\
1164 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1166 static handle_exception_result
1167 handle_exception (struct target_waitstatus
*ourstatus
)
1169 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1170 DWORD code
= rec
->ExceptionCode
;
1171 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1173 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1175 /* Record the context of the current thread. */
1176 thread_rec (current_event
.dwThreadId
, -1);
1180 case EXCEPTION_ACCESS_VIOLATION
:
1181 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1182 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1185 /* See if the access violation happened within the cygwin DLL
1186 itself. Cygwin uses a kind of exception handling to deal
1187 with passed-in invalid addresses. gdb should not treat
1188 these as real SEGVs since they will be silently handled by
1189 cygwin. A real SEGV will (theoretically) be caught by
1190 cygwin later in the process and will be sent as a
1191 cygwin-specific-signal. So, ignore SEGVs if they show up
1192 within the text segment of the DLL itself. */
1194 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1196 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1197 && addr
< cygwin_load_end
))
1198 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1199 && startswith (fn
, "KERNEL32!IsBad")))
1200 return HANDLE_EXCEPTION_UNHANDLED
;
1204 case STATUS_STACK_OVERFLOW
:
1205 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1206 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1208 case STATUS_FLOAT_DENORMAL_OPERAND
:
1209 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1210 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1212 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1213 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1214 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1216 case STATUS_FLOAT_INEXACT_RESULT
:
1217 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1218 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1220 case STATUS_FLOAT_INVALID_OPERATION
:
1221 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1222 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1224 case STATUS_FLOAT_OVERFLOW
:
1225 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1226 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1228 case STATUS_FLOAT_STACK_CHECK
:
1229 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1230 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1232 case STATUS_FLOAT_UNDERFLOW
:
1233 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1234 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1236 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1237 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1238 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1240 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1241 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1242 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1244 case STATUS_INTEGER_OVERFLOW
:
1245 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1246 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1248 case EXCEPTION_BREAKPOINT
:
1249 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1250 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1253 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1254 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1256 case DBG_CONTROL_BREAK
:
1257 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1258 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1260 case EXCEPTION_SINGLE_STEP
:
1261 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1264 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1265 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1266 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1268 case EXCEPTION_PRIV_INSTRUCTION
:
1269 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1270 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1272 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1273 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1274 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1276 case MS_VC_EXCEPTION
:
1277 if (rec
->NumberParameters
>= 3
1278 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1280 DWORD named_thread_id
;
1281 windows_thread_info
*named_thread
;
1282 CORE_ADDR thread_name_target
;
1284 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1286 thread_name_target
= rec
->ExceptionInformation
[1];
1287 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1289 if (named_thread_id
== (DWORD
) -1)
1290 named_thread_id
= current_event
.dwThreadId
;
1292 named_thread
= thread_rec (named_thread_id
, 0);
1293 if (named_thread
!= NULL
)
1295 int thread_name_len
;
1296 gdb::unique_xmalloc_ptr
<char> thread_name
;
1298 thread_name_len
= target_read_string (thread_name_target
,
1299 &thread_name
, 1025, NULL
);
1300 if (thread_name_len
> 0)
1302 thread_name
.get ()[thread_name_len
- 1] = '\0';
1303 xfree (named_thread
->name
);
1304 named_thread
->name
= thread_name
.release ();
1307 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1308 result
= HANDLE_EXCEPTION_IGNORED
;
1311 /* treat improperly formed exception as unknown */
1314 /* Treat unhandled first chance exceptions specially. */
1315 if (current_event
.u
.Exception
.dwFirstChance
)
1316 return HANDLE_EXCEPTION_UNHANDLED
;
1317 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1318 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1319 host_address_to_string (
1320 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1321 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1325 last_sig
= ourstatus
->value
.sig
;
1329 /* Resume thread specified by ID, or all artificially suspended
1330 threads, if we are continuing execution. KILLED non-zero means we
1331 have killed the inferior, so we should ignore weird errors due to
1332 threads shutting down. */
1334 windows_continue (DWORD continue_status
, int id
, int killed
)
1336 windows_thread_info
*th
;
1339 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1340 (unsigned) current_event
.dwProcessId
,
1341 (unsigned) current_event
.dwThreadId
,
1342 continue_status
== DBG_CONTINUE
?
1343 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1345 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1346 if ((id
== -1 || id
== (int) th
->id
)
1349 if (debug_registers_changed
)
1351 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1352 th
->context
.Dr0
= dr
[0];
1353 th
->context
.Dr1
= dr
[1];
1354 th
->context
.Dr2
= dr
[2];
1355 th
->context
.Dr3
= dr
[3];
1356 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1357 th
->context
.Dr7
= dr
[7];
1359 if (th
->context
.ContextFlags
)
1363 if (GetExitCodeThread (th
->h
, &ec
)
1364 && ec
== STILL_ACTIVE
)
1366 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1371 th
->context
.ContextFlags
= 0;
1373 if (th
->suspended
> 0)
1374 (void) ResumeThread (th
->h
);
1378 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1379 current_event
.dwThreadId
,
1383 error (_("Failed to resume program execution"
1384 " (ContinueDebugEvent failed, error %u)"),
1385 (unsigned int) GetLastError ());
1387 debug_registers_changed
= 0;
1391 /* Called in pathological case where Windows fails to send a
1392 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1394 fake_create_process (void)
1396 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1397 current_event
.dwProcessId
);
1398 if (current_process_handle
!= NULL
)
1399 open_process_used
= 1;
1402 error (_("OpenProcess call failed, GetLastError = %u"),
1403 (unsigned) GetLastError ());
1404 /* We can not debug anything in that case. */
1407 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1408 current_event
.dwThreadId
),
1409 current_event
.u
.CreateThread
.hThread
,
1410 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1411 true /* main_thread_p */);
1412 return current_event
.dwThreadId
;
1416 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1418 windows_thread_info
*th
;
1419 DWORD continue_status
= DBG_CONTINUE
;
1421 /* A specific PTID means `step only this thread id'. */
1422 int resume_all
= ptid
== minus_one_ptid
;
1424 /* If we're continuing all threads, it's the current inferior that
1425 should be handled specially. */
1427 ptid
= inferior_ptid
;
1429 if (sig
!= GDB_SIGNAL_0
)
1431 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1433 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1435 else if (sig
== last_sig
)
1436 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1439 /* This code does not seem to work, because
1440 the kernel does probably not consider changes in the ExceptionRecord
1441 structure when passing the exception to the inferior.
1442 Note that this seems possible in the exception handler itself. */
1444 for (const xlate_exception
&x
: xlate
)
1447 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1449 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1452 if (continue_status
== DBG_CONTINUE
)
1454 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1458 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1462 last_sig
= GDB_SIGNAL_0
;
1464 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1465 ptid
.pid (), ptid
.tid (), step
, sig
));
1467 /* Get context for currently selected thread. */
1468 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1473 /* Single step by setting t bit. */
1474 struct regcache
*regcache
= get_current_regcache ();
1475 struct gdbarch
*gdbarch
= regcache
->arch ();
1476 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1477 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1480 if (th
->context
.ContextFlags
)
1482 if (debug_registers_changed
)
1484 th
->context
.Dr0
= dr
[0];
1485 th
->context
.Dr1
= dr
[1];
1486 th
->context
.Dr2
= dr
[2];
1487 th
->context
.Dr3
= dr
[3];
1488 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1489 th
->context
.Dr7
= dr
[7];
1491 CHECK (SetThreadContext (th
->h
, &th
->context
));
1492 th
->context
.ContextFlags
= 0;
1496 /* Allow continuing with the same signal that interrupted us.
1497 Otherwise complain. */
1500 windows_continue (continue_status
, -1, 0);
1502 windows_continue (continue_status
, ptid
.tid (), 0);
1505 /* Ctrl-C handler used when the inferior is not run in the same console. The
1506 handler is in charge of interrupting the inferior using DebugBreakProcess.
1507 Note that this function is not available prior to Windows XP. In this case
1508 we emit a warning. */
1510 ctrl_c_handler (DWORD event_type
)
1512 const int attach_flag
= current_inferior ()->attach_flag
;
1514 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1515 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1518 /* If the inferior and the debugger share the same console, do nothing as
1519 the inferior has also received the Ctrl-C event. */
1520 if (!new_console
&& !attach_flag
)
1523 if (!DebugBreakProcess (current_process_handle
))
1524 warning (_("Could not interrupt program. "
1525 "Press Ctrl-c in the program console."));
1527 /* Return true to tell that Ctrl-C has been handled. */
1531 /* Get the next event from the child. Returns a non-zero thread id if the event
1532 requires handling by WFI (or whatever). */
1534 get_windows_debug_event (struct target_ops
*ops
,
1535 int pid
, struct target_waitstatus
*ourstatus
)
1538 DWORD continue_status
, event_code
;
1539 windows_thread_info
*th
;
1540 static windows_thread_info dummy_thread_info
;
1541 DWORD thread_id
= 0;
1543 last_sig
= GDB_SIGNAL_0
;
1545 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1549 continue_status
= DBG_CONTINUE
;
1551 event_code
= current_event
.dwDebugEventCode
;
1552 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1554 have_saved_context
= 0;
1558 case CREATE_THREAD_DEBUG_EVENT
:
1559 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1560 (unsigned) current_event
.dwProcessId
,
1561 (unsigned) current_event
.dwThreadId
,
1562 "CREATE_THREAD_DEBUG_EVENT"));
1563 if (saw_create
!= 1)
1565 struct inferior
*inf
;
1566 inf
= find_inferior_pid (current_event
.dwProcessId
);
1567 if (!saw_create
&& inf
->attach_flag
)
1569 /* Kludge around a Windows bug where first event is a create
1570 thread event. Caused when attached process does not have
1572 thread_id
= fake_create_process ();
1578 /* Record the existence of this thread. */
1579 thread_id
= current_event
.dwThreadId
;
1580 th
= windows_add_thread
1581 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1582 current_event
.u
.CreateThread
.hThread
,
1583 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1584 false /* main_thread_p */);
1588 case EXIT_THREAD_DEBUG_EVENT
:
1589 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1590 (unsigned) current_event
.dwProcessId
,
1591 (unsigned) current_event
.dwThreadId
,
1592 "EXIT_THREAD_DEBUG_EVENT"));
1593 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1594 current_event
.dwThreadId
),
1595 current_event
.u
.ExitThread
.dwExitCode
,
1596 false /* main_thread_p */);
1597 th
= &dummy_thread_info
;
1600 case CREATE_PROCESS_DEBUG_EVENT
:
1601 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1602 (unsigned) current_event
.dwProcessId
,
1603 (unsigned) current_event
.dwThreadId
,
1604 "CREATE_PROCESS_DEBUG_EVENT"));
1605 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1606 if (++saw_create
!= 1)
1609 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1610 /* Add the main thread. */
1611 th
= windows_add_thread
1612 (ptid_t (current_event
.dwProcessId
, 0,
1613 current_event
.dwThreadId
),
1614 current_event
.u
.CreateProcessInfo
.hThread
,
1615 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1616 true /* main_thread_p */);
1617 thread_id
= current_event
.dwThreadId
;
1620 case EXIT_PROCESS_DEBUG_EVENT
:
1621 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1622 (unsigned) current_event
.dwProcessId
,
1623 (unsigned) current_event
.dwThreadId
,
1624 "EXIT_PROCESS_DEBUG_EVENT"));
1625 if (!windows_initialization_done
)
1627 target_terminal::ours ();
1628 target_mourn_inferior (inferior_ptid
);
1629 error (_("During startup program exited with code 0x%x."),
1630 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1632 else if (saw_create
== 1)
1634 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1635 current_event
.dwThreadId
),
1636 0, true /* main_thread_p */);
1637 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1638 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1639 thread_id
= current_event
.dwThreadId
;
1643 case LOAD_DLL_DEBUG_EVENT
:
1644 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1645 (unsigned) current_event
.dwProcessId
,
1646 (unsigned) current_event
.dwThreadId
,
1647 "LOAD_DLL_DEBUG_EVENT"));
1648 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1649 if (saw_create
!= 1 || ! windows_initialization_done
)
1651 catch_errors (handle_load_dll
);
1652 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1653 ourstatus
->value
.integer
= 0;
1654 thread_id
= current_event
.dwThreadId
;
1657 case UNLOAD_DLL_DEBUG_EVENT
:
1658 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1659 (unsigned) current_event
.dwProcessId
,
1660 (unsigned) current_event
.dwThreadId
,
1661 "UNLOAD_DLL_DEBUG_EVENT"));
1662 if (saw_create
!= 1 || ! windows_initialization_done
)
1664 catch_errors (handle_unload_dll
);
1665 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1666 ourstatus
->value
.integer
= 0;
1667 thread_id
= current_event
.dwThreadId
;
1670 case EXCEPTION_DEBUG_EVENT
:
1671 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1672 (unsigned) current_event
.dwProcessId
,
1673 (unsigned) current_event
.dwThreadId
,
1674 "EXCEPTION_DEBUG_EVENT"));
1675 if (saw_create
!= 1)
1677 switch (handle_exception (ourstatus
))
1679 case HANDLE_EXCEPTION_UNHANDLED
:
1681 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1683 case HANDLE_EXCEPTION_HANDLED
:
1684 thread_id
= current_event
.dwThreadId
;
1686 case HANDLE_EXCEPTION_IGNORED
:
1687 continue_status
= DBG_CONTINUE
;
1692 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1693 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1694 (unsigned) current_event
.dwProcessId
,
1695 (unsigned) current_event
.dwThreadId
,
1696 "OUTPUT_DEBUG_STRING_EVENT"));
1697 if (saw_create
!= 1)
1699 thread_id
= handle_output_debug_string (ourstatus
);
1703 if (saw_create
!= 1)
1705 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1706 (unsigned) current_event
.dwProcessId
,
1707 (unsigned) current_event
.dwThreadId
);
1708 printf_unfiltered (" unknown event code %u\n",
1709 (unsigned) current_event
.dwDebugEventCode
);
1713 if (!thread_id
|| saw_create
!= 1)
1715 CHECK (windows_continue (continue_status
, -1, 0));
1719 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1720 current_thread
= th
;
1721 if (!current_thread
)
1722 current_thread
= thread_rec (thread_id
, TRUE
);
1729 /* Wait for interesting events to occur in the target process. */
1731 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1736 /* We loop when we get a non-standard exception rather than return
1737 with a SPURIOUS because resume can try and step or modify things,
1738 which needs a current_thread->h. But some of these exceptions mark
1739 the birth or death of threads, which mean that the current thread
1740 isn't necessarily what you think it is. */
1746 /* If the user presses Ctrl-c while the debugger is waiting
1747 for an event, he expects the debugger to interrupt his program
1748 and to get the prompt back. There are two possible situations:
1750 - The debugger and the program do not share the console, in
1751 which case the Ctrl-c event only reached the debugger.
1752 In that case, the ctrl_c handler will take care of interrupting
1753 the inferior. Note that this case is working starting with
1754 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1757 - The debugger and the program share the same console, in which
1758 case both debugger and inferior will receive the Ctrl-c event.
1759 In that case the ctrl_c handler will ignore the event, as the
1760 Ctrl-c event generated inside the inferior will trigger the
1761 expected debug event.
1763 FIXME: brobecker/2008-05-20: If the inferior receives the
1764 signal first and the delay until GDB receives that signal
1765 is sufficiently long, GDB can sometimes receive the SIGINT
1766 after we have unblocked the CTRL+C handler. This would
1767 lead to the debugger stopping prematurely while handling
1768 the new-thread event that comes with the handling of the SIGINT
1769 inside the inferior, and then stop again immediately when
1770 the user tries to resume the execution in the inferior.
1771 This is a classic race that we should try to fix one day. */
1772 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1773 retval
= get_windows_debug_event (this, pid
, ourstatus
);
1774 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1777 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1782 if (deprecated_ui_loop_hook
!= NULL
)
1783 detach
= deprecated_ui_loop_hook (0);
1791 /* Iterate over all DLLs currently mapped by our inferior, and
1792 add them to our list of solibs. */
1795 windows_add_all_dlls (void)
1797 HMODULE dummy_hmodule
;
1802 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1803 sizeof (HMODULE
), &cb_needed
) == 0)
1809 hmodules
= (HMODULE
*) alloca (cb_needed
);
1810 if (EnumProcessModules (current_process_handle
, hmodules
,
1811 cb_needed
, &cb_needed
) == 0)
1814 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1818 wchar_t dll_name
[__PMAX
];
1821 char dll_name
[__PMAX
];
1824 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1825 &mi
, sizeof (mi
)) == 0)
1827 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1828 dll_name
, sizeof (dll_name
)) == 0)
1831 wcstombs (name
, dll_name
, __PMAX
);
1836 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1837 solib_end
= solib_end
->next
;
1842 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1845 struct inferior
*inf
;
1847 last_sig
= GDB_SIGNAL_0
;
1849 exception_count
= 0;
1850 open_process_used
= 0;
1851 debug_registers_changed
= 0;
1852 debug_registers_used
= 0;
1853 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1856 cygwin_load_start
= cygwin_load_end
= 0;
1858 current_event
.dwProcessId
= pid
;
1859 memset (¤t_event
, 0, sizeof (current_event
));
1860 if (!target_is_pushed (ops
))
1862 disable_breakpoints_in_shlibs ();
1863 windows_clear_solib ();
1864 clear_proceed_status (0);
1865 init_wait_for_inferior ();
1867 inf
= current_inferior ();
1868 inferior_appeared (inf
, pid
);
1869 inf
->attach_flag
= attaching
;
1871 /* Make the new process the current inferior, so terminal handling
1872 can rely on it. When attaching, we don't know about any thread
1873 id here, but that's OK --- nothing should be referencing the
1874 current thread until we report an event out of windows_wait. */
1875 inferior_ptid
= ptid_t (pid
);
1877 target_terminal::init ();
1878 target_terminal::inferior ();
1880 windows_initialization_done
= 0;
1884 struct target_waitstatus status
;
1886 ops
->wait (minus_one_ptid
, &status
, 0);
1888 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1890 if (status
.kind
!= TARGET_WAITKIND_LOADED
1891 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1894 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1897 /* Now that the inferior has been started and all DLLs have been mapped,
1898 we can iterate over all DLLs and load them in.
1900 We avoid doing it any earlier because, on certain versions of Windows,
1901 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1902 we have seen on Windows 8.1 that the ntdll.dll load event does not
1903 include the DLL name, preventing us from creating an associated SO.
1904 A possible explanation is that ntdll.dll might be mapped before
1905 the SO info gets created by the Windows system -- ntdll.dll is
1906 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1907 do not seem to suffer from that problem.
1909 Rather than try to work around this sort of issue, it is much
1910 simpler to just ignore DLL load/unload events during the startup
1911 phase, and then process them all in one batch now. */
1912 windows_add_all_dlls ();
1914 windows_initialization_done
= 1;
1918 /* Try to set or remove a user privilege to the current process. Return -1
1919 if that fails, the previous setting of that privilege otherwise.
1921 This code is copied from the Cygwin source code and rearranged to allow
1922 dynamically loading of the needed symbols from advapi32 which is only
1923 available on NT/2K/XP. */
1925 set_process_privilege (const char *privilege
, BOOL enable
)
1927 HANDLE token_hdl
= NULL
;
1929 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1933 if (!OpenProcessToken (GetCurrentProcess (),
1934 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1938 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1941 new_priv
.PrivilegeCount
= 1;
1942 new_priv
.Privileges
[0].Luid
= restore_priv
;
1943 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1945 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1946 sizeof orig_priv
, &orig_priv
, &size
))
1949 /* Disabled, otherwise every `attach' in an unprivileged user session
1950 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1951 windows_attach(). */
1952 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1953 be enabled. GetLastError () returns an correct error code, though. */
1954 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1958 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1962 CloseHandle (token_hdl
);
1967 /* Attach to process PID, then initialize for debugging it. */
1970 windows_nat_target::attach (const char *args
, int from_tty
)
1975 pid
= parse_pid_to_attach (args
);
1977 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1979 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1980 printf_unfiltered ("This can cause attach to "
1981 "fail on Windows NT/2K/XP\n");
1984 windows_init_thread_list ();
1985 ok
= DebugActiveProcess (pid
);
1991 /* Try fall back to Cygwin pid. */
1992 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1995 ok
= DebugActiveProcess (pid
);
2000 error (_("Can't attach to process."));
2002 DebugSetProcessKillOnExit (FALSE
);
2006 char *exec_file
= (char *) get_exec_file (0);
2009 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2010 target_pid_to_str (ptid_t (pid
)).c_str ());
2012 printf_unfiltered ("Attaching to %s\n",
2013 target_pid_to_str (ptid_t (pid
)).c_str ());
2016 do_initial_windows_stuff (this, pid
, 1);
2017 target_terminal::ours ();
2021 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2025 ptid_t ptid
= minus_one_ptid
;
2026 resume (ptid
, 0, GDB_SIGNAL_0
);
2028 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2030 error (_("Can't detach process %u (error %u)"),
2031 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2034 DebugSetProcessKillOnExit (FALSE
);
2036 if (detached
&& from_tty
)
2038 const char *exec_file
= get_exec_file (0);
2041 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2042 (unsigned) current_event
.dwProcessId
);
2045 x86_cleanup_dregs ();
2046 inferior_ptid
= null_ptid
;
2047 detach_inferior (inf
);
2049 maybe_unpush_target ();
2052 /* Try to determine the executable filename.
2054 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2056 Upon success, the filename is stored inside EXE_NAME_RET, and
2057 this function returns nonzero.
2059 Otherwise, this function returns zero and the contents of
2060 EXE_NAME_RET is undefined. */
2063 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2070 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2071 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2074 /* We know the executable is always first in the list of modules,
2075 which we just fetched. So no need to fetch more. */
2079 /* Cygwin prefers that the path be in /x/y/z format, so extract
2080 the filename into a temporary buffer first, and then convert it
2081 to POSIX format into the destination buffer. */
2082 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2084 len
= GetModuleFileNameEx (current_process_handle
,
2085 dh_buf
, pathbuf
, exe_name_max_len
);
2087 error (_("Error getting executable filename: %u."),
2088 (unsigned) GetLastError ());
2089 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2090 exe_name_max_len
) < 0)
2091 error (_("Error converting executable filename to POSIX: %d."), errno
);
2094 len
= GetModuleFileNameEx (current_process_handle
,
2095 dh_buf
, exe_name_ret
, exe_name_max_len
);
2097 error (_("Error getting executable filename: %u."),
2098 (unsigned) GetLastError ());
2101 return 1; /* success */
2104 /* The pid_to_exec_file target_ops method for this platform. */
2107 windows_nat_target::pid_to_exec_file (int pid
)
2109 static char path
[__PMAX
];
2111 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2113 char procexe
[sizeof ("/proc/4294967295/exe")];
2115 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2116 nchars
= readlink (procexe
, path
, sizeof(path
));
2117 if (nchars
> 0 && nchars
< sizeof (path
))
2119 path
[nchars
] = '\0'; /* Got it */
2124 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2125 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2126 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2132 /* Print status information about what we're accessing. */
2135 windows_nat_target::files_info ()
2137 struct inferior
*inf
= current_inferior ();
2139 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2140 inf
->attach_flag
? "attached" : "child",
2141 target_pid_to_str (inferior_ptid
).c_str ());
2144 /* Modify CreateProcess parameters for use of a new separate console.
2146 *FLAGS: DWORD parameter for general process creation flags.
2147 *SI: STARTUPINFO structure, for which the console window size and
2148 console buffer size is filled in if GDB is running in a console.
2149 to create the new console.
2150 The size of the used font is not available on all versions of
2151 Windows OS. Furthermore, the current font might not be the default
2152 font, but this is still better than before.
2153 If the windows and buffer sizes are computed,
2154 SI->DWFLAGS is changed so that this information is used
2155 by CreateProcess function. */
2158 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2160 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2161 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2163 if (hconsole
!= INVALID_HANDLE_VALUE
)
2165 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2167 CONSOLE_FONT_INFO cfi
;
2169 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2170 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2171 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2172 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2173 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2175 si
->dwXSize
*= font_size
.X
;
2179 si
->dwYSize
*= font_size
.Y
;
2182 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2183 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2184 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2186 *flags
|= CREATE_NEW_CONSOLE
;
2190 /* Function called by qsort to sort environment strings. */
2193 envvar_cmp (const void *a
, const void *b
)
2195 const char **p
= (const char **) a
;
2196 const char **q
= (const char **) b
;
2197 return strcasecmp (*p
, *q
);
2203 clear_win32_environment (char **env
)
2207 wchar_t *copy
= NULL
, *equalpos
;
2209 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2211 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2212 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2213 mbstowcs (copy
, env
[i
], len
);
2214 equalpos
= wcschr (copy
, L
'=');
2217 SetEnvironmentVariableW (copy
, NULL
);
2225 /* Redirection of inferior I/O streams for native MS-Windows programs.
2226 Unlike on Unix, where this is handled by invoking the inferior via
2227 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2229 The official documentation of the cmd.exe redirection features is here:
2231 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2233 (That page talks about Windows XP, but there's no newer
2234 documentation, so we assume later versions of cmd.exe didn't change
2237 Caveat: the documentation on that page seems to include a few lies.
2238 For example, it describes strange constructs 1<&2 and 2<&1, which
2239 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2240 think the cmd.exe parser of the redirection symbols simply doesn't
2241 care about the < vs > distinction in these cases. Therefore, the
2242 supported features are explicitly documented below.
2244 The emulation below aims at supporting all the valid use cases
2245 supported by cmd.exe, which include:
2247 < FILE redirect standard input from FILE
2248 0< FILE redirect standard input from FILE
2249 <&N redirect standard input from file descriptor N
2250 0<&N redirect standard input from file descriptor N
2251 > FILE redirect standard output to FILE
2252 >> FILE append standard output to FILE
2253 1>> FILE append standard output to FILE
2254 >&N redirect standard output to file descriptor N
2255 1>&N redirect standard output to file descriptor N
2256 >>&N append standard output to file descriptor N
2257 1>>&N append standard output to file descriptor N
2258 2> FILE redirect standard error to FILE
2259 2>> FILE append standard error to FILE
2260 2>&N redirect standard error to file descriptor N
2261 2>>&N append standard error to file descriptor N
2263 Note that using N > 2 in the above construct is supported, but
2264 requires that the corresponding file descriptor be open by some
2265 means elsewhere or outside GDB. Also note that using ">&0" or
2266 "<&2" will generally fail, because the file descriptor redirected
2267 from is normally open in an incompatible mode (e.g., FD 0 is open
2268 for reading only). IOW, use of such tricks is not recommended;
2269 you are on your own.
2271 We do NOT support redirection of file descriptors above 2, as in
2272 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2273 that needs special handling in the startup code that MinGW
2274 doesn't have). Pipes are also not supported.
2276 As for invalid use cases, where the redirection contains some
2277 error, the emulation below will detect that and produce some
2278 error and/or failure. But the behavior in those cases is not
2279 bug-for-bug compatible with what cmd.exe does in those cases.
2280 That's because what cmd.exe does then is not well defined, and
2281 seems to be a side effect of the cmd.exe parsing of the command
2282 line more than anything else. For example, try redirecting to an
2283 invalid file name, as in "> foo:bar".
2285 There are also minor syntactic deviations from what cmd.exe does
2286 in some corner cases. For example, it doesn't support the likes
2287 of "> &foo" to mean redirect to file named literally "&foo"; we
2288 do support that here, because that, too, sounds like some issue
2289 with the cmd.exe parser. Another nicety is that we support
2290 redirection targets that use file names with forward slashes,
2291 something cmd.exe doesn't -- this comes in handy since GDB
2292 file-name completion can be used when typing the command line for
2295 /* Support routines for redirecting standard handles of the inferior. */
2297 /* Parse a single redirection spec, open/duplicate the specified
2298 file/fd, and assign the appropriate value to one of the 3 standard
2299 file descriptors. */
2301 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2303 int *fd
, ref_fd
= -2;
2305 const char *fname
= redir_string
+ 1;
2306 int rc
= *redir_string
;
2321 fd
= (rc
== '2') ? err
: out
;
2322 mode
= O_WRONLY
| O_CREAT
;
2335 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2337 /* A reference to a file descriptor. */
2339 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2340 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2342 /* Don't allow redirection when open modes are incompatible. */
2343 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2344 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2351 else if (ref_fd
== 1)
2353 else if (ref_fd
== 2)
2363 fname
++; /* skip the separator space */
2364 /* If the descriptor is already open, close it. This allows
2365 multiple specs of redirections for the same stream, which is
2366 somewhat nonsensical, but still valid and supported by cmd.exe.
2367 (But cmd.exe only opens a single file in this case, the one
2368 specified by the last redirection spec on the command line.) */
2373 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2377 else if (ref_fd
== -1)
2378 *fd
= -1; /* reset to default destination */
2381 *fd
= _dup (ref_fd
);
2385 /* _open just sets a flag for O_APPEND, which won't be passed to the
2386 inferior, so we need to actually move the file pointer. */
2387 if ((mode
& O_APPEND
) != 0)
2388 _lseek (*fd
, 0L, SEEK_END
);
2392 /* Canonicalize a single redirection spec and set up the corresponding
2393 file descriptor as specified. */
2395 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2397 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2399 const char *start
= s
;
2402 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2403 if ((*start
== '>' || *start
== '1' || *start
== '2')
2407 if (*s
== '>' && *start
!= '>')
2410 else if (*start
== '0' && *s
== '<')
2412 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2415 while (isspace (*s
)) /* skip whitespace before file name */
2417 *d
++ = ' '; /* separate file name with a single space */
2420 /* Copy the file name. */
2423 /* Remove quoting characters from the file name in buf[]. */
2424 if (*s
== '"') /* could support '..' quoting here */
2428 else if (*s
== quote
)
2436 else if (*s
== '\\')
2438 if (s
[1] == '"') /* could support '..' here */
2442 else if (isspace (*s
) && !quote
)
2446 if (d
- buf
>= sizeof (buf
) - 1)
2448 errno
= ENAMETOOLONG
;
2454 /* Windows doesn't allow redirection characters in file names, so we
2455 can bail out early if they use them, or if there's no target file
2456 name after the redirection symbol. */
2457 if (d
[-1] == '>' || d
[-1] == '<')
2462 if (redir_open (buf
, inp
, out
, err
) == 0)
2467 /* Parse the command line for redirection specs and prepare the file
2468 descriptors for the 3 standard streams accordingly. */
2470 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2471 int *inp
, int *out
, int *err
)
2473 const char *s
= cmd_orig
;
2476 bool retval
= false;
2478 while (isspace (*s
))
2483 if (*s
== '"') /* could also support '..' quoting here */
2487 else if (*s
== quote
)
2490 else if (*s
== '\\')
2492 if (s
[1] == '"') /* escaped quote char */
2497 /* Process a single redirection candidate. */
2498 if (*s
== '<' || *s
== '>'
2499 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2500 || (*s
== '0' && s
[1] == '<'))
2502 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2516 #endif /* !__CYGWIN__ */
2518 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2519 EXEC_FILE is the file to run.
2520 ALLARGS is a string containing the arguments to the program.
2521 ENV is the environment vector to pass. Errors reported with error(). */
2524 windows_nat_target::create_inferior (const char *exec_file
,
2525 const std::string
&origallargs
,
2526 char **in_env
, int from_tty
)
2530 cygwin_buf_t real_path
[__PMAX
];
2531 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2532 cygwin_buf_t infcwd
[__PMAX
];
2534 cygwin_buf_t
*toexec
;
2535 cygwin_buf_t
*cygallargs
;
2537 char **old_env
= NULL
;
2541 int ostdin
, ostdout
, ostderr
;
2542 #else /* !__CYGWIN__ */
2543 char shell
[__PMAX
]; /* Path to shell */
2545 char *args
, *allargs_copy
;
2546 size_t args_len
, allargs_len
;
2547 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2548 HANDLE tty
= INVALID_HANDLE_VALUE
;
2549 bool redirected
= false;
2556 #endif /* !__CYGWIN__ */
2557 const char *allargs
= origallargs
.c_str ();
2558 PROCESS_INFORMATION pi
;
2561 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2564 error (_("No executable specified, use `target exec'."));
2566 const char *inferior_cwd
= get_inferior_cwd ();
2567 std::string expanded_infcwd
;
2568 if (inferior_cwd
!= NULL
)
2570 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2571 /* Mirror slashes on inferior's cwd. */
2572 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2574 inferior_cwd
= expanded_infcwd
.c_str ();
2577 memset (&si
, 0, sizeof (si
));
2578 si
.cb
= sizeof (si
);
2581 flags
|= CREATE_NEW_PROCESS_GROUP
;
2584 windows_set_console_info (&si
, &flags
);
2589 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2590 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2591 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2592 error (_("Error starting executable: %d"), errno
);
2595 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2596 if (len
== (size_t) -1)
2597 error (_("Error starting executable: %d"), errno
);
2598 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2599 mbstowcs (cygallargs
, allargs
, len
);
2600 #else /* !__USEWIDE */
2601 cygallargs
= allargs
;
2607 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2608 error (_("Error starting executable via shell: %d"), errno
);
2610 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2611 + mbstowcs (NULL
, allargs
, 0) + 2;
2612 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2613 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2614 #else /* !__USEWIDE */
2615 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2616 + strlen (allargs
) + 2);
2617 cygallargs
= (char *) alloca (len
);
2618 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2619 #endif /* __USEWIDE */
2621 flags
|= DEBUG_PROCESS
;
2624 if (inferior_cwd
!= NULL
2625 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2626 infcwd
, strlen (inferior_cwd
)) < 0)
2627 error (_("Error converting inferior cwd: %d"), errno
);
2630 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2631 * sizeof (wchar_t));
2632 wcscpy (args
, toexec
);
2633 wcscat (args
, L
" ");
2634 wcscat (args
, cygallargs
);
2635 #else /* !__USEWIDE */
2636 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2637 strcpy (args
, toexec
);
2639 strcat (args
, cygallargs
);
2640 #endif /* !__USEWIDE */
2642 #ifdef CW_CVT_ENV_TO_WINENV
2643 /* First try to create a direct Win32 copy of the POSIX environment. */
2644 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2645 if (w32_env
!= (PWCHAR
) -1)
2646 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2648 /* If that fails, fall back to old method tweaking GDB's environment. */
2649 #endif /* CW_CVT_ENV_TO_WINENV */
2651 /* Reset all Win32 environment variables to avoid leftover on next run. */
2652 clear_win32_environment (environ
);
2653 /* Prepare the environment vars for CreateProcess. */
2656 cygwin_internal (CW_SYNC_WINENV
);
2660 if (!inferior_io_terminal
)
2661 tty
= ostdin
= ostdout
= ostderr
= -1;
2664 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2667 print_sys_errmsg (inferior_io_terminal
, errno
);
2668 ostdin
= ostdout
= ostderr
= -1;
2681 windows_init_thread_list ();
2682 ret
= CreateProcess (0,
2683 args
, /* command line */
2684 NULL
, /* Security */
2686 TRUE
, /* inherit handles */
2687 flags
, /* start flags */
2688 w32_env
, /* environment */
2689 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2694 /* Just free the Win32 environment, if it could be created. */
2698 /* Reset all environment variables to avoid leftover on next run. */
2699 clear_win32_environment (in_env
);
2700 /* Restore normal GDB environment variables. */
2702 cygwin_internal (CW_SYNC_WINENV
);
2715 #else /* !__CYGWIN__ */
2716 allargs_len
= strlen (allargs
);
2717 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2718 if (strpbrk (allargs_copy
, "<>") != NULL
)
2723 redirect_inferior_handles (allargs
, allargs_copy
,
2724 &fd_inp
, &fd_out
, &fd_err
);
2726 warning (_("Error in redirection: %s."), strerror (errno
));
2729 allargs_len
= strlen (allargs_copy
);
2731 /* If not all the standard streams are redirected by the command
2732 line, use inferior_io_terminal for those which aren't. */
2733 if (inferior_io_terminal
2734 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2736 SECURITY_ATTRIBUTES sa
;
2737 sa
.nLength
= sizeof(sa
);
2738 sa
.lpSecurityDescriptor
= 0;
2739 sa
.bInheritHandle
= TRUE
;
2740 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2741 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2742 if (tty
== INVALID_HANDLE_VALUE
)
2743 warning (_("Warning: Failed to open TTY %s, error %#x."),
2744 inferior_io_terminal
, (unsigned) GetLastError ());
2746 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2749 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2750 else if (tty
!= INVALID_HANDLE_VALUE
)
2753 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2755 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2756 else if (tty
!= INVALID_HANDLE_VALUE
)
2757 si
.hStdOutput
= tty
;
2759 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2761 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2762 else if (tty
!= INVALID_HANDLE_VALUE
)
2765 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2766 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2770 /* Build the command line, a space-separated list of tokens where
2771 the first token is the name of the module to be executed.
2772 To avoid ambiguities introduced by spaces in the module name,
2774 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2775 args
= (char *) alloca (args_len
);
2776 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2778 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2780 /* CreateProcess takes the environment list as a null terminated set of
2781 strings (i.e. two nulls terminate the list). */
2783 /* Get total size for env strings. */
2784 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2785 envlen
+= strlen (in_env
[i
]) + 1;
2787 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2788 env
= (char **) alloca (envsize
);
2789 memcpy (env
, in_env
, envsize
);
2790 /* Windows programs expect the environment block to be sorted. */
2791 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2793 w32env
= (char *) alloca (envlen
+ 1);
2795 /* Copy env strings into new buffer. */
2796 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2798 strcpy (temp
, env
[i
]);
2799 temp
+= strlen (temp
) + 1;
2802 /* Final nil string to terminate new env. */
2805 windows_init_thread_list ();
2806 ret
= CreateProcessA (0,
2807 args
, /* command line */
2808 NULL
, /* Security */
2810 TRUE
, /* inherit handles */
2811 flags
, /* start flags */
2812 w32env
, /* environment */
2813 inferior_cwd
, /* current directory */
2816 if (tty
!= INVALID_HANDLE_VALUE
)
2824 #endif /* !__CYGWIN__ */
2827 error (_("Error creating process %s, (error %u)."),
2828 exec_file
, (unsigned) GetLastError ());
2830 CloseHandle (pi
.hThread
);
2831 CloseHandle (pi
.hProcess
);
2833 if (useshell
&& shell
[0] != '\0')
2838 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2840 /* windows_continue (DBG_CONTINUE, -1, 0); */
2844 windows_nat_target::mourn_inferior ()
2846 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2847 x86_cleanup_dregs();
2848 if (open_process_used
)
2850 CHECK (CloseHandle (current_process_handle
));
2851 open_process_used
= 0;
2853 inf_child_target::mourn_inferior ();
2856 /* Send a SIGINT to the process group. This acts just like the user typed a
2857 ^C on the controlling terminal. */
2860 windows_nat_target::interrupt ()
2862 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2863 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2864 registers_changed (); /* refresh register state */
2867 /* Helper for windows_xfer_partial that handles memory transfers.
2868 Arguments are like target_xfer_partial. */
2870 static enum target_xfer_status
2871 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2872 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2876 DWORD lasterror
= 0;
2878 if (writebuf
!= NULL
)
2880 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2881 pulongest (len
), core_addr_to_string (memaddr
)));
2882 success
= WriteProcessMemory (current_process_handle
,
2883 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2886 lasterror
= GetLastError ();
2887 FlushInstructionCache (current_process_handle
,
2888 (LPCVOID
) (uintptr_t) memaddr
, len
);
2892 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2893 pulongest (len
), core_addr_to_string (memaddr
)));
2894 success
= ReadProcessMemory (current_process_handle
,
2895 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2898 lasterror
= GetLastError ();
2900 *xfered_len
= (ULONGEST
) done
;
2901 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2902 return TARGET_XFER_OK
;
2904 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2908 windows_nat_target::kill ()
2910 CHECK (TerminateProcess (current_process_handle
, 0));
2914 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2916 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2918 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2922 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2926 windows_nat_target::close ()
2928 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2929 inferior_ptid
.pid ()));
2932 /* Convert pid to printable format. */
2934 windows_nat_target::pid_to_str (ptid_t ptid
)
2936 if (ptid
.tid () != 0)
2937 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2939 return normal_pid_to_str (ptid
);
2942 static enum target_xfer_status
2943 windows_xfer_shared_libraries (struct target_ops
*ops
,
2944 enum target_object object
, const char *annex
,
2945 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2946 ULONGEST offset
, ULONGEST len
,
2947 ULONGEST
*xfered_len
)
2949 struct obstack obstack
;
2955 return TARGET_XFER_E_IO
;
2957 obstack_init (&obstack
);
2958 obstack_grow_str (&obstack
, "<library-list>\n");
2959 for (so
= solib_start
.next
; so
; so
= so
->next
)
2961 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2963 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2964 (uintptr_t) li
->load_addr
,
2965 target_gdbarch (), &obstack
);
2967 obstack_grow_str0 (&obstack
, "</library-list>\n");
2969 buf
= (const char *) obstack_finish (&obstack
);
2970 len_avail
= strlen (buf
);
2971 if (offset
>= len_avail
)
2975 if (len
> len_avail
- offset
)
2976 len
= len_avail
- offset
;
2977 memcpy (readbuf
, buf
+ offset
, len
);
2980 obstack_free (&obstack
, NULL
);
2981 *xfered_len
= (ULONGEST
) len
;
2982 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2985 enum target_xfer_status
2986 windows_nat_target::xfer_partial (enum target_object object
,
2987 const char *annex
, gdb_byte
*readbuf
,
2988 const gdb_byte
*writebuf
, ULONGEST offset
,
2989 ULONGEST len
, ULONGEST
*xfered_len
)
2993 case TARGET_OBJECT_MEMORY
:
2994 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2996 case TARGET_OBJECT_LIBRARIES
:
2997 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
2998 writebuf
, offset
, len
, xfered_len
);
3001 if (beneath () == NULL
)
3003 /* This can happen when requesting the transfer of unsupported
3004 objects before a program has been started (and therefore
3005 with the current_target having no target beneath). */
3006 return TARGET_XFER_E_IO
;
3008 return beneath ()->xfer_partial (object
, annex
,
3009 readbuf
, writebuf
, offset
, len
,
3014 /* Provide thread local base, i.e. Thread Information Block address.
3015 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3018 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3020 windows_thread_info
*th
;
3022 th
= thread_rec (ptid
.tid (), 0);
3027 *addr
= th
->thread_local_base
;
3033 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3035 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3038 /* Implementation of the to_thread_name method. */
3041 windows_nat_target::thread_name (struct thread_info
*thr
)
3043 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3048 _initialize_windows_nat (void)
3050 x86_dr_low
.set_control
= cygwin_set_dr7
;
3051 x86_dr_low
.set_addr
= cygwin_set_dr
;
3052 x86_dr_low
.get_addr
= cygwin_get_dr
;
3053 x86_dr_low
.get_status
= cygwin_get_dr6
;
3054 x86_dr_low
.get_control
= cygwin_get_dr7
;
3056 /* x86_dr_low.debug_register_length field is set by
3057 calling x86_set_debug_register_length function
3058 in processor windows specific native file. */
3060 add_inf_child_target (&the_windows_nat_target
);
3063 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3066 add_com ("signal-event", class_run
, signal_event_command
, _("\
3067 Signal a crashed process with event ID, to allow its debugging.\n\
3068 This command is needed in support of setting up GDB as JIT debugger on \
3069 MS-Windows. The command should be invoked from the GDB command line using \
3070 the '-ex' command-line option. The ID of the event that blocks the \
3071 crashed process will be supplied by the Windows JIT debugging mechanism."));
3074 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3075 Set use of shell to start subprocess."), _("\
3076 Show use of shell to start subprocess."), NULL
,
3078 NULL
, /* FIXME: i18n: */
3079 &setlist
, &showlist
);
3081 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3082 &cygwin_exceptions
, _("\
3083 Break when an exception is detected in the Cygwin DLL itself."), _("\
3084 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3086 NULL
, /* FIXME: i18n: */
3087 &setlist
, &showlist
);
3090 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3091 Set creation of new console when creating child process."), _("\
3092 Show creation of new console when creating child process."), NULL
,
3094 NULL
, /* FIXME: i18n: */
3095 &setlist
, &showlist
);
3097 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3098 Set creation of new group when creating child process."), _("\
3099 Show creation of new group when creating child process."), NULL
,
3101 NULL
, /* FIXME: i18n: */
3102 &setlist
, &showlist
);
3104 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3105 Set whether to display execution in child process."), _("\
3106 Show whether to display execution in child process."), NULL
,
3108 NULL
, /* FIXME: i18n: */
3109 &setlist
, &showlist
);
3111 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3112 Set whether to display kernel events in child process."), _("\
3113 Show whether to display kernel events in child process."), NULL
,
3115 NULL
, /* FIXME: i18n: */
3116 &setlist
, &showlist
);
3118 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3119 Set whether to display memory accesses in child process."), _("\
3120 Show whether to display memory accesses in child process."), NULL
,
3122 NULL
, /* FIXME: i18n: */
3123 &setlist
, &showlist
);
3125 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3126 &debug_exceptions
, _("\
3127 Set whether to display kernel exceptions in child process."), _("\
3128 Show whether to display kernel exceptions in child process."), NULL
,
3130 NULL
, /* FIXME: i18n: */
3131 &setlist
, &showlist
);
3133 init_w32_command_list ();
3135 add_cmd ("selector", class_info
, display_selectors
,
3136 _("Display selectors infos."),
3140 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3142 /* Pass the address ADDR to the inferior in the I'th debug register.
3143 Here we just store the address in dr array, the registers will be
3144 actually set up when windows_continue is called. */
3146 cygwin_set_dr (int i
, CORE_ADDR addr
)
3149 internal_error (__FILE__
, __LINE__
,
3150 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3152 debug_registers_changed
= 1;
3153 debug_registers_used
= 1;
3156 /* Pass the value VAL to the inferior in the DR7 debug control
3157 register. Here we just store the address in D_REGS, the watchpoint
3158 will be actually set up in windows_wait. */
3160 cygwin_set_dr7 (unsigned long val
)
3162 dr
[7] = (CORE_ADDR
) val
;
3163 debug_registers_changed
= 1;
3164 debug_registers_used
= 1;
3167 /* Get the value of debug register I from the inferior. */
3170 cygwin_get_dr (int i
)
3175 /* Get the value of the DR6 debug status register from the inferior.
3176 Here we just return the value stored in dr[6]
3177 by the last call to thread_rec for current_event.dwThreadId id. */
3178 static unsigned long
3179 cygwin_get_dr6 (void)
3181 return (unsigned long) dr
[6];
3184 /* Get the value of the DR7 debug status register from the inferior.
3185 Here we just return the value stored in dr[7] by the last call to
3186 thread_rec for current_event.dwThreadId id. */
3188 static unsigned long
3189 cygwin_get_dr7 (void)
3191 return (unsigned long) dr
[7];
3194 /* Determine if the thread referenced by "ptid" is alive
3195 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3196 it means that the thread has died. Otherwise it is assumed to be alive. */
3199 windows_nat_target::thread_alive (ptid_t ptid
)
3203 gdb_assert (ptid
.tid () != 0);
3206 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3210 _initialize_check_for_gdb_ini (void)
3213 if (inhibit_gdbinit
)
3216 homedir
= getenv ("HOME");
3220 char *oldini
= (char *) alloca (strlen (homedir
) +
3221 sizeof ("gdb.ini") + 1);
3222 strcpy (oldini
, homedir
);
3223 p
= strchr (oldini
, '\0');
3224 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3226 strcpy (p
, "gdb.ini");
3227 if (access (oldini
, 0) == 0)
3229 int len
= strlen (oldini
);
3230 char *newini
= (char *) alloca (len
+ 2);
3232 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3233 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3234 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3239 /* Define dummy functions which always return error for the rare cases where
3240 these functions could not be found. */
3242 bad_DebugActiveProcessStop (DWORD w
)
3247 bad_DebugBreakProcess (HANDLE w
)
3252 bad_DebugSetProcessKillOnExit (BOOL w
)
3257 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3264 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3270 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3277 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3283 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3289 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3295 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3303 /* Load any functions which may not be available in ancient versions
3307 _initialize_loadable (void)
3311 #define GPA(m, func) \
3312 func = (func ## _ftype *) GetProcAddress (m, #func)
3314 hm
= LoadLibrary ("kernel32.dll");
3317 GPA (hm
, DebugActiveProcessStop
);
3318 GPA (hm
, DebugBreakProcess
);
3319 GPA (hm
, DebugSetProcessKillOnExit
);
3320 GPA (hm
, GetConsoleFontSize
);
3321 GPA (hm
, DebugActiveProcessStop
);
3322 GPA (hm
, GetCurrentConsoleFont
);
3325 /* Set variables to dummy versions of these processes if the function
3326 wasn't found in kernel32.dll. */
3327 if (!DebugBreakProcess
)
3328 DebugBreakProcess
= bad_DebugBreakProcess
;
3329 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3331 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3332 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3334 if (!GetConsoleFontSize
)
3335 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3336 if (!GetCurrentConsoleFont
)
3337 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3339 /* Load optional functions used for retrieving filename information
3340 associated with the currently debugged process or its dlls. */
3341 hm
= LoadLibrary ("psapi.dll");
3344 GPA (hm
, EnumProcessModules
);
3345 GPA (hm
, GetModuleInformation
);
3346 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3347 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3350 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3352 /* Set variables to dummy versions of these processes if the function
3353 wasn't found in psapi.dll. */
3354 EnumProcessModules
= bad_EnumProcessModules
;
3355 GetModuleInformation
= bad_GetModuleInformation
;
3356 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3357 /* This will probably fail on Windows 9x/Me. Let the user know
3358 that we're missing some functionality. */
3360 cannot automatically find executable file or library to read symbols.\n\
3361 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3364 hm
= LoadLibrary ("advapi32.dll");
3367 GPA (hm
, OpenProcessToken
);
3368 GPA (hm
, LookupPrivilegeValueA
);
3369 GPA (hm
, AdjustTokenPrivileges
);
3370 /* Only need to set one of these since if OpenProcessToken fails nothing
3372 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3373 || !AdjustTokenPrivileges
)
3374 OpenProcessToken
= bad_OpenProcessToken
;