1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2020 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"
71 #include "gdbsupport/gdb_wait.h"
73 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
74 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
75 #define DebugBreakProcess dyn_DebugBreakProcess
76 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
77 #define EnumProcessModules dyn_EnumProcessModules
78 #define GetModuleInformation dyn_GetModuleInformation
79 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
80 #define OpenProcessToken dyn_OpenProcessToken
81 #define GetConsoleFontSize dyn_GetConsoleFontSize
82 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
84 typedef BOOL
WINAPI (AdjustTokenPrivileges_ftype
) (HANDLE
, BOOL
,
86 DWORD
, PTOKEN_PRIVILEGES
,
88 static AdjustTokenPrivileges_ftype
*AdjustTokenPrivileges
;
90 typedef BOOL
WINAPI (DebugActiveProcessStop_ftype
) (DWORD
);
91 static DebugActiveProcessStop_ftype
*DebugActiveProcessStop
;
93 typedef BOOL
WINAPI (DebugBreakProcess_ftype
) (HANDLE
);
94 static DebugBreakProcess_ftype
*DebugBreakProcess
;
96 typedef BOOL
WINAPI (DebugSetProcessKillOnExit_ftype
) (BOOL
);
97 static DebugSetProcessKillOnExit_ftype
*DebugSetProcessKillOnExit
;
99 typedef BOOL
WINAPI (EnumProcessModules_ftype
) (HANDLE
, HMODULE
*, DWORD
,
101 static EnumProcessModules_ftype
*EnumProcessModules
;
103 typedef BOOL
WINAPI (GetModuleInformation_ftype
) (HANDLE
, HMODULE
,
104 LPMODULEINFO
, DWORD
);
105 static GetModuleInformation_ftype
*GetModuleInformation
;
107 typedef BOOL
WINAPI (LookupPrivilegeValueA_ftype
) (LPCSTR
, LPCSTR
, PLUID
);
108 static LookupPrivilegeValueA_ftype
*LookupPrivilegeValueA
;
110 typedef BOOL
WINAPI (OpenProcessToken_ftype
) (HANDLE
, DWORD
, PHANDLE
);
111 static OpenProcessToken_ftype
*OpenProcessToken
;
113 typedef BOOL
WINAPI (GetCurrentConsoleFont_ftype
) (HANDLE
, BOOL
,
114 CONSOLE_FONT_INFO
*);
115 static GetCurrentConsoleFont_ftype
*GetCurrentConsoleFont
;
117 typedef COORD
WINAPI (GetConsoleFontSize_ftype
) (HANDLE
, DWORD
);
118 static GetConsoleFontSize_ftype
*GetConsoleFontSize
;
122 #undef GetModuleFileNameEx
125 # define __PMAX (MAX_PATH + 1)
126 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
127 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
128 # define STARTUPINFO STARTUPINFOA
129 # define CreateProcess CreateProcessA
130 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
131 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
133 # define __PMAX PATH_MAX
134 /* The starting and ending address of the cygwin1.dll text segment. */
135 static CORE_ADDR cygwin_load_start
;
136 static CORE_ADDR cygwin_load_end
;
138 typedef wchar_t cygwin_buf_t
;
139 typedef DWORD
WINAPI (GetModuleFileNameEx_ftype
) (HANDLE
, HMODULE
,
141 static GetModuleFileNameEx_ftype
*GetModuleFileNameEx
;
142 # define STARTUPINFO STARTUPINFOW
143 # define CreateProcess CreateProcessW
144 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
145 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
148 static int have_saved_context
; /* True if we've saved context from a
151 static CONTEXT saved_context
; /* Contains the saved context from a
155 /* If we're not using the old Cygwin header file set, define the
156 following which never should have been in the generic Win32 API
157 headers in the first place since they were our own invention... */
158 #ifndef _GNU_H_WINDOWS_H
161 FLAG_TRACE_BIT
= 0x100,
165 #ifndef CONTEXT_EXTENDED_REGISTERS
166 /* This macro is only defined on ia32. It only makes sense on this target,
167 so define it as zero if not already defined. */
168 #define CONTEXT_EXTENDED_REGISTERS 0
171 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
172 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
173 | CONTEXT_EXTENDED_REGISTERS
175 static uintptr_t dr
[8];
176 static int debug_registers_changed
;
177 static int debug_registers_used
;
179 static int windows_initialization_done
;
180 #define DR6_CLEAR_VALUE 0xffff0ff0
182 /* The exception thrown by a program to tell the debugger the name of
183 a thread. The exception record contains an ID of a thread and a
184 name to give it. This exception has no documented name, but MSDN
185 dubs it "MS_VC_EXCEPTION" in one code example. */
186 #define MS_VC_EXCEPTION 0x406d1388
190 HANDLE_EXCEPTION_UNHANDLED
= 0,
191 HANDLE_EXCEPTION_HANDLED
,
192 HANDLE_EXCEPTION_IGNORED
193 } handle_exception_result
;
195 /* The string sent by cygwin when it processes a signal.
196 FIXME: This should be in a cygwin include file. */
197 #ifndef _CYGWIN_SIGNAL_STRING
198 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
201 #define CHECK(x) check (x, __FILE__,__LINE__)
202 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
203 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
204 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
205 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
207 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
208 static void cygwin_set_dr7 (unsigned long val
);
209 static CORE_ADDR
cygwin_get_dr (int i
);
210 static unsigned long cygwin_get_dr6 (void);
211 static unsigned long cygwin_get_dr7 (void);
213 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
214 /* Set if a signal was received from the debugged process. */
216 /* Thread information structure used to track information that is
217 not available in gdb's thread structure. */
218 typedef struct windows_thread_info_struct
220 struct windows_thread_info_struct
*next
;
223 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
;
354 int get_windows_debug_event (int pid
, struct target_waitstatus
*ourstatus
);
357 static windows_nat_target the_windows_nat_target
;
359 /* Set the MAPPINGS static global to OFFSETS.
360 See the description of MAPPINGS for more details. */
363 windows_set_context_register_offsets (const int *offsets
)
368 /* See windows-nat.h. */
371 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
373 segment_register_p
= fun
;
377 check (BOOL ok
, const char *file
, int line
)
380 printf_filtered ("error return %s:%d was %u\n", file
, line
,
381 (unsigned) GetLastError ());
384 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
385 then also retrieve the context for this thread. If GET_CONTEXT is
386 negative, then don't suspend the thread. */
387 static windows_thread_info
*
388 thread_rec (DWORD id
, int get_context
)
390 windows_thread_info
*th
;
392 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
395 if (!th
->suspended
&& get_context
)
397 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
399 if (SuspendThread (th
->h
) == (DWORD
) -1)
401 DWORD err
= GetLastError ();
403 /* We get Access Denied (5) when trying to suspend
404 threads that Windows started on behalf of the
405 debuggee, usually when those threads are just
407 We can get Invalid Handle (6) if the main thread
409 if (err
!= ERROR_INVALID_HANDLE
410 && err
!= ERROR_ACCESS_DENIED
)
411 warning (_("SuspendThread (tid=0x%x) failed."
413 (unsigned) id
, (unsigned) err
);
419 else if (get_context
< 0)
421 th
->reload_context
= 1;
429 /* Add a thread to the thread list.
431 PTID is the ptid of the thread to be added.
432 H is its Windows handle.
433 TLB is its thread local base.
434 MAIN_THREAD_P should be true if the thread to be added is
435 the main thread, false otherwise. */
437 static windows_thread_info
*
438 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
, bool main_thread_p
)
440 windows_thread_info
*th
;
443 gdb_assert (ptid
.tid () != 0);
447 if ((th
= thread_rec (id
, FALSE
)))
450 th
= XCNEW (windows_thread_info
);
453 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
454 th
->next
= thread_head
.next
;
455 thread_head
.next
= th
;
457 /* Add this new thread to the list of threads.
459 To be consistent with what's done on other platforms, we add
460 the main thread silently (in reality, this thread is really
461 more of a process to the user than a thread). */
463 add_thread_silent (&the_windows_nat_target
, ptid
);
465 add_thread (&the_windows_nat_target
, ptid
);
467 /* Set the debug registers for the new thread if they are used. */
468 if (debug_registers_used
)
470 /* Only change the value of the debug registers. */
471 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
472 CHECK (GetThreadContext (th
->h
, &th
->context
));
473 th
->context
.Dr0
= dr
[0];
474 th
->context
.Dr1
= dr
[1];
475 th
->context
.Dr2
= dr
[2];
476 th
->context
.Dr3
= dr
[3];
477 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
478 th
->context
.Dr7
= dr
[7];
479 CHECK (SetThreadContext (th
->h
, &th
->context
));
480 th
->context
.ContextFlags
= 0;
485 /* Clear out any old thread list and reinitialize it to a
488 windows_init_thread_list (void)
490 windows_thread_info
*th
= &thread_head
;
492 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
494 while (th
->next
!= NULL
)
496 windows_thread_info
*here
= th
->next
;
497 th
->next
= here
->next
;
500 thread_head
.next
= NULL
;
503 /* Delete a thread from the list of threads.
505 PTID is the ptid of the thread to be deleted.
506 EXIT_CODE is the thread's exit code.
507 MAIN_THREAD_P should be true if the thread to be deleted is
508 the main thread, false otherwise. */
511 windows_delete_thread (ptid_t ptid
, DWORD exit_code
, bool main_thread_p
)
513 windows_thread_info
*th
;
516 gdb_assert (ptid
.tid () != 0);
520 /* Emit a notification about the thread being deleted.
522 Note that no notification was printed when the main thread
523 was created, and thus, unless in verbose mode, we should be
524 symmetrical, and avoid that notification for the main thread
528 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
).c_str ());
529 else if (print_thread_events
&& !main_thread_p
)
530 printf_unfiltered (_("[%s exited with code %u]\n"),
531 target_pid_to_str (ptid
).c_str (),
532 (unsigned) exit_code
);
534 delete_thread (find_thread_ptid (&the_windows_nat_target
, ptid
));
536 for (th
= &thread_head
;
537 th
->next
!= NULL
&& th
->next
->id
!= id
;
541 if (th
->next
!= NULL
)
543 windows_thread_info
*here
= th
->next
;
544 th
->next
= here
->next
;
550 /* Fetches register number R from the given windows_thread_info,
551 and supplies its value to the given regcache.
553 This function assumes that R is non-negative. A failed assertion
554 is raised if that is not true.
556 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
557 that the windows_thread_info has an up-to-date context. A failed
558 assertion is raised if that assumption is violated. */
561 windows_fetch_one_register (struct regcache
*regcache
,
562 windows_thread_info
*th
, int r
)
565 gdb_assert (!th
->reload_context
);
567 char *context_offset
= ((char *) &th
->context
) + mappings
[r
];
568 struct gdbarch
*gdbarch
= regcache
->arch ();
569 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
571 if (r
== I387_FISEG_REGNUM (tdep
))
573 long l
= *((long *) context_offset
) & 0xffff;
574 regcache
->raw_supply (r
, (char *) &l
);
576 else if (r
== I387_FOP_REGNUM (tdep
))
578 long l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
579 regcache
->raw_supply (r
, (char *) &l
);
581 else if (segment_register_p (r
))
583 /* GDB treats segment registers as 32bit registers, but they are
584 in fact only 16 bits long. Make sure we do not read extra
585 bits from our source buffer. */
586 long l
= *((long *) context_offset
) & 0xffff;
587 regcache
->raw_supply (r
, (char *) &l
);
590 regcache
->raw_supply (r
, context_offset
);
594 windows_nat_target::fetch_registers (struct regcache
*regcache
, int r
)
596 DWORD tid
= regcache
->ptid ().tid ();
597 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
599 /* Check if TH exists. Windows sometimes uses a non-existent
600 thread id in its events. */
604 if (th
->reload_context
)
607 if (have_saved_context
)
609 /* Lie about where the program actually is stopped since
610 cygwin has informed us that we should consider the signal
611 to have occurred at another location which is stored in
613 memcpy (&th
->context
, &saved_context
,
614 __COPY_CONTEXT_SIZE
);
615 have_saved_context
= 0;
620 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
621 CHECK (GetThreadContext (th
->h
, &th
->context
));
622 /* Copy dr values from that thread.
623 But only if there were not modified since last stop.
625 if (!debug_registers_changed
)
627 dr
[0] = th
->context
.Dr0
;
628 dr
[1] = th
->context
.Dr1
;
629 dr
[2] = th
->context
.Dr2
;
630 dr
[3] = th
->context
.Dr3
;
631 dr
[6] = th
->context
.Dr6
;
632 dr
[7] = th
->context
.Dr7
;
635 th
->reload_context
= 0;
639 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch()); r
++)
640 windows_fetch_one_register (regcache
, th
, r
);
642 windows_fetch_one_register (regcache
, th
, r
);
645 /* Collect the register number R from the given regcache, and store
646 its value into the corresponding area of the given thread's context.
648 This function assumes that R is non-negative. A failed assertion
649 assertion is raised if that is not true. */
652 windows_store_one_register (const struct regcache
*regcache
,
653 windows_thread_info
*th
, int r
)
657 regcache
->raw_collect (r
, ((char *) &th
->context
) + mappings
[r
]);
660 /* Store a new register value into the context of the thread tied to
664 windows_nat_target::store_registers (struct regcache
*regcache
, int r
)
666 DWORD tid
= regcache
->ptid ().tid ();
667 windows_thread_info
*th
= thread_rec (tid
, TRUE
);
669 /* Check if TH exists. Windows sometimes uses a non-existent
670 thread id in its events. */
675 for (r
= 0; r
< gdbarch_num_regs (regcache
->arch ()); r
++)
676 windows_store_one_register (regcache
, th
, r
);
678 windows_store_one_register (regcache
, th
, r
);
681 /* Maintain a linked list of "so" information. */
682 struct lm_info_windows
: public lm_info_base
684 LPVOID load_addr
= 0;
687 static struct so_list solib_start
, *solib_end
;
689 static struct so_list
*
690 windows_make_so (const char *name
, LPVOID load_addr
)
697 WIN32_FIND_DATA w32_fd
;
698 HANDLE h
= FindFirstFile(name
, &w32_fd
);
700 if (h
== INVALID_HANDLE_VALUE
)
706 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
708 p
= strrchr (buf
, '\\');
711 SetCurrentDirectory (buf
);
712 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
713 SetCurrentDirectory (cwd
);
716 if (strcasecmp (buf
, "ntdll.dll") == 0)
718 GetSystemDirectory (buf
, sizeof (buf
));
719 strcat (buf
, "\\ntdll.dll");
722 cygwin_buf_t buf
[__PMAX
];
725 if (access (name
, F_OK
) != 0)
727 if (strcasecmp (name
, "ntdll.dll") == 0)
730 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
731 wcscat (buf
, L
"\\ntdll.dll");
735 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
736 strcat (buf
, "\\ntdll.dll");
741 so
= XCNEW (struct so_list
);
742 lm_info_windows
*li
= new lm_info_windows
;
744 li
->load_addr
= load_addr
;
745 strcpy (so
->so_original_name
, name
);
747 strcpy (so
->so_name
, buf
);
750 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
751 SO_NAME_MAX_PATH_SIZE
);
754 char *rname
= realpath (name
, NULL
);
755 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
757 strcpy (so
->so_name
, rname
);
761 error (_("dll path too long"));
763 /* Record cygwin1.dll .text start/end. */
764 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
765 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
767 asection
*text
= NULL
;
769 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (so
->so_name
, "pei-i386", -1));
774 if (bfd_check_format (abfd
.get (), bfd_object
))
775 text
= bfd_get_section_by_name (abfd
.get (), ".text");
780 /* The symbols in a dll are offset by 0x1000, which is the
781 offset from 0 of the first byte in an image - because of the
782 file header and the section alignment. */
783 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
785 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (text
);
793 get_image_name (HANDLE h
, void *address
, int unicode
)
796 static char buf
[__PMAX
];
798 static char buf
[(2 * __PMAX
) + 1];
800 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
806 /* Attempt to read the name of the dll that was detected.
807 This is documented to work only when actively debugging
808 a program. It will not work for attached processes. */
812 /* See if we could read the address of a string, and that the
813 address isn't null. */
814 if (!ReadProcessMemory (h
, address
, &address_ptr
,
815 sizeof (address_ptr
), &done
)
816 || done
!= sizeof (address_ptr
) || !address_ptr
)
819 /* Find the length of the string. */
820 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
821 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
825 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
828 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
829 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
832 wcstombs (buf
, unicode_address
, __PMAX
);
834 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
842 /* Handle a DLL load event, and return 1.
844 This function assumes that this event did not occur during inferior
845 initialization, where their event info may be incomplete (see
846 do_initial_windows_stuff and windows_add_all_dlls for more info
847 on how we handle DLL loading during that phase). */
852 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
855 /* Try getting the DLL name via the lpImageName field of the event.
856 Note that Microsoft documents this fields as strictly optional,
857 in the sense that it might be NULL. And the first DLL event in
858 particular is explicitly documented as "likely not pass[ed]"
859 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
860 dll_name
= get_image_name (current_process_handle
,
861 event
->lpImageName
, event
->fUnicode
);
865 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
866 solib_end
= solib_end
->next
;
868 lm_info_windows
*li
= (lm_info_windows
*) solib_end
->lm_info
;
870 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
871 host_address_to_string (li
->load_addr
)));
875 windows_free_so (struct so_list
*so
)
877 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
883 /* Handle a DLL unload event.
884 Return 1 if successful, or zero otherwise.
886 This function assumes that this event did not occur during inferior
887 initialization, where their event info may be incomplete (see
888 do_initial_windows_stuff and windows_add_all_dlls for more info
889 on how we handle DLL loading during that phase). */
894 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
897 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
899 lm_info_windows
*li_next
= (lm_info_windows
*) so
->next
->lm_info
;
901 if (li_next
->load_addr
== lpBaseOfDll
)
903 struct so_list
*sodel
= so
->next
;
905 so
->next
= sodel
->next
;
908 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
910 windows_free_so (sodel
);
915 /* We did not find any DLL that was previously loaded at this address,
916 so register a complaint. We do not report an error, because we have
917 observed that this may be happening under some circumstances. For
918 instance, running 32bit applications on x64 Windows causes us to receive
919 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
920 events are apparently caused by the WOW layer, the interface between
921 32bit and 64bit worlds). */
922 complaint (_("dll starting at %s not found."),
923 host_address_to_string (lpBaseOfDll
));
926 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
930 catch_errors (void (*func
) ())
936 catch (const gdb_exception
&ex
)
938 exception_print (gdb_stderr
, ex
);
942 /* Clear list of loaded DLLs. */
944 windows_clear_solib (void)
948 for (so
= solib_start
.next
; so
; so
= solib_start
.next
)
950 solib_start
.next
= so
->next
;
951 windows_free_so (so
);
954 solib_end
= &solib_start
;
958 signal_event_command (const char *args
, int from_tty
)
960 uintptr_t event_id
= 0;
961 char *endargs
= NULL
;
964 error (_("signal-event requires an argument (integer event id)"));
966 event_id
= strtoumax (args
, &endargs
, 10);
968 if ((errno
== ERANGE
) || (event_id
== 0) || (event_id
> UINTPTR_MAX
) ||
969 ((HANDLE
) event_id
== INVALID_HANDLE_VALUE
))
970 error (_("Failed to convert `%s' to event id"), args
);
972 SetEvent ((HANDLE
) event_id
);
973 CloseHandle ((HANDLE
) event_id
);
976 /* Handle DEBUG_STRING output from child process.
977 Cygwin prepends its messages with a "cygwin:". Interpret this as
978 a Cygwin signal. Otherwise just print the string as a warning. */
980 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
982 gdb::unique_xmalloc_ptr
<char> s
;
985 if (!target_read_string
986 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
988 || !s
|| !*(s
.get ()))
990 else if (!startswith (s
.get (), _CYGWIN_SIGNAL_STRING
))
993 if (!startswith (s
.get (), "cYg"))
996 char *p
= strchr (s
.get (), '\0');
998 if (p
> s
.get () && *--p
== '\n')
1000 warning (("%s"), s
.get ());
1006 /* Got a cygwin signal marker. A cygwin signal is followed by
1007 the signal number itself and then optionally followed by the
1008 thread id and address to saved context within the DLL. If
1009 these are supplied, then the given thread is assumed to have
1010 issued the signal and the context from the thread is assumed
1011 to be stored at the given address in the inferior. Tell gdb
1012 to treat this like a real signal. */
1014 int sig
= strtol (s
.get () + sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
1015 gdb_signal gotasig
= gdb_signal_from_host (sig
);
1017 ourstatus
->value
.sig
= gotasig
;
1023 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1024 retval
= strtoul (p
, &p
, 0);
1026 retval
= current_event
.dwThreadId
;
1027 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
1028 && ReadProcessMemory (current_process_handle
, x
,
1030 __COPY_CONTEXT_SIZE
, &n
)
1031 && n
== __COPY_CONTEXT_SIZE
)
1032 have_saved_context
= 1;
1041 display_selector (HANDLE thread
, DWORD sel
)
1044 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1047 printf_filtered ("0x%03x: ", (unsigned) sel
);
1048 if (!info
.HighWord
.Bits
.Pres
)
1050 puts_filtered ("Segment not present\n");
1053 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1054 (info
.HighWord
.Bits
.BaseMid
<< 16)
1056 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1057 if (info
.HighWord
.Bits
.Granularity
)
1058 limit
= (limit
<< 12) | 0xfff;
1059 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1060 if (info
.HighWord
.Bits
.Default_Big
)
1061 puts_filtered(" 32-bit ");
1063 puts_filtered(" 16-bit ");
1064 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1067 puts_filtered ("Data (Read-Only, Exp-up");
1070 puts_filtered ("Data (Read/Write, Exp-up");
1073 puts_filtered ("Unused segment (");
1076 puts_filtered ("Data (Read/Write, Exp-down");
1079 puts_filtered ("Code (Exec-Only, N.Conf");
1082 puts_filtered ("Code (Exec/Read, N.Conf");
1085 puts_filtered ("Code (Exec-Only, Conf");
1088 puts_filtered ("Code (Exec/Read, Conf");
1091 printf_filtered ("Unknown type 0x%lx",
1092 (unsigned long) info
.HighWord
.Bits
.Type
);
1094 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1095 puts_filtered(", N.Acc");
1096 puts_filtered (")\n");
1097 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1098 puts_filtered("System selector ");
1099 printf_filtered ("Priviledge level = %ld. ",
1100 (unsigned long) info
.HighWord
.Bits
.Dpl
);
1101 if (info
.HighWord
.Bits
.Granularity
)
1102 puts_filtered ("Page granular.\n");
1104 puts_filtered ("Byte granular.\n");
1109 DWORD err
= GetLastError ();
1110 if (err
== ERROR_NOT_SUPPORTED
)
1111 printf_filtered ("Function not supported\n");
1113 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1119 display_selectors (const char * args
, int from_tty
)
1121 if (!current_thread
)
1123 puts_filtered ("Impossible to display selectors now.\n");
1129 puts_filtered ("Selector $cs\n");
1130 display_selector (current_thread
->h
,
1131 current_thread
->context
.SegCs
);
1132 puts_filtered ("Selector $ds\n");
1133 display_selector (current_thread
->h
,
1134 current_thread
->context
.SegDs
);
1135 puts_filtered ("Selector $es\n");
1136 display_selector (current_thread
->h
,
1137 current_thread
->context
.SegEs
);
1138 puts_filtered ("Selector $ss\n");
1139 display_selector (current_thread
->h
,
1140 current_thread
->context
.SegSs
);
1141 puts_filtered ("Selector $fs\n");
1142 display_selector (current_thread
->h
,
1143 current_thread
->context
.SegFs
);
1144 puts_filtered ("Selector $gs\n");
1145 display_selector (current_thread
->h
,
1146 current_thread
->context
.SegGs
);
1151 sel
= parse_and_eval_long (args
);
1152 printf_filtered ("Selector \"%s\"\n",args
);
1153 display_selector (current_thread
->h
, sel
);
1157 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1158 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1159 host_address_to_string (\
1160 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1162 static handle_exception_result
1163 handle_exception (struct target_waitstatus
*ourstatus
)
1165 EXCEPTION_RECORD
*rec
= ¤t_event
.u
.Exception
.ExceptionRecord
;
1166 DWORD code
= rec
->ExceptionCode
;
1167 handle_exception_result result
= HANDLE_EXCEPTION_HANDLED
;
1169 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1171 /* Record the context of the current thread. */
1172 thread_rec (current_event
.dwThreadId
, -1);
1176 case EXCEPTION_ACCESS_VIOLATION
:
1177 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1178 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1181 /* See if the access violation happened within the cygwin DLL
1182 itself. Cygwin uses a kind of exception handling to deal
1183 with passed-in invalid addresses. gdb should not treat
1184 these as real SEGVs since they will be silently handled by
1185 cygwin. A real SEGV will (theoretically) be caught by
1186 cygwin later in the process and will be sent as a
1187 cygwin-specific-signal. So, ignore SEGVs if they show up
1188 within the text segment of the DLL itself. */
1190 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t) rec
->ExceptionAddress
;
1192 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1193 && addr
< cygwin_load_end
))
1194 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1195 && startswith (fn
, "KERNEL32!IsBad")))
1196 return HANDLE_EXCEPTION_UNHANDLED
;
1200 case STATUS_STACK_OVERFLOW
:
1201 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1202 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1204 case STATUS_FLOAT_DENORMAL_OPERAND
:
1205 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1206 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1208 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1209 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1210 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1212 case STATUS_FLOAT_INEXACT_RESULT
:
1213 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1214 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1216 case STATUS_FLOAT_INVALID_OPERATION
:
1217 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1218 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1220 case STATUS_FLOAT_OVERFLOW
:
1221 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1222 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1224 case STATUS_FLOAT_STACK_CHECK
:
1225 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1226 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1228 case STATUS_FLOAT_UNDERFLOW
:
1229 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1230 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1232 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1233 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1234 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1236 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1237 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1238 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1240 case STATUS_INTEGER_OVERFLOW
:
1241 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1242 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1244 case EXCEPTION_BREAKPOINT
:
1245 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1246 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1249 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1250 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1252 case DBG_CONTROL_BREAK
:
1253 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1254 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1256 case EXCEPTION_SINGLE_STEP
:
1257 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1258 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1260 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1261 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1262 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1264 case EXCEPTION_PRIV_INSTRUCTION
:
1265 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1266 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1268 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1269 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1270 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1272 case MS_VC_EXCEPTION
:
1273 if (rec
->NumberParameters
>= 3
1274 && (rec
->ExceptionInformation
[0] & 0xffffffff) == 0x1000)
1276 DWORD named_thread_id
;
1277 windows_thread_info
*named_thread
;
1278 CORE_ADDR thread_name_target
;
1280 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1282 thread_name_target
= rec
->ExceptionInformation
[1];
1283 named_thread_id
= (DWORD
) (0xffffffff & rec
->ExceptionInformation
[2]);
1285 if (named_thread_id
== (DWORD
) -1)
1286 named_thread_id
= current_event
.dwThreadId
;
1288 named_thread
= thread_rec (named_thread_id
, 0);
1289 if (named_thread
!= NULL
)
1291 int thread_name_len
;
1292 gdb::unique_xmalloc_ptr
<char> thread_name
;
1294 thread_name_len
= target_read_string (thread_name_target
,
1295 &thread_name
, 1025, NULL
);
1296 if (thread_name_len
> 0)
1298 thread_name
.get ()[thread_name_len
- 1] = '\0';
1299 xfree (named_thread
->name
);
1300 named_thread
->name
= thread_name
.release ();
1303 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1304 result
= HANDLE_EXCEPTION_IGNORED
;
1307 /* treat improperly formed exception as unknown */
1310 /* Treat unhandled first chance exceptions specially. */
1311 if (current_event
.u
.Exception
.dwFirstChance
)
1312 return HANDLE_EXCEPTION_UNHANDLED
;
1313 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1314 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1315 host_address_to_string (
1316 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1317 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1321 last_sig
= ourstatus
->value
.sig
;
1325 /* Resume thread specified by ID, or all artificially suspended
1326 threads, if we are continuing execution. KILLED non-zero means we
1327 have killed the inferior, so we should ignore weird errors due to
1328 threads shutting down. */
1330 windows_continue (DWORD continue_status
, int id
, int killed
)
1332 windows_thread_info
*th
;
1335 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1336 (unsigned) current_event
.dwProcessId
,
1337 (unsigned) current_event
.dwThreadId
,
1338 continue_status
== DBG_CONTINUE
?
1339 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1341 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1342 if ((id
== -1 || id
== (int) th
->id
)
1345 if (debug_registers_changed
)
1347 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1348 th
->context
.Dr0
= dr
[0];
1349 th
->context
.Dr1
= dr
[1];
1350 th
->context
.Dr2
= dr
[2];
1351 th
->context
.Dr3
= dr
[3];
1352 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1353 th
->context
.Dr7
= dr
[7];
1355 if (th
->context
.ContextFlags
)
1359 if (GetExitCodeThread (th
->h
, &ec
)
1360 && ec
== STILL_ACTIVE
)
1362 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1367 th
->context
.ContextFlags
= 0;
1369 if (th
->suspended
> 0)
1370 (void) ResumeThread (th
->h
);
1374 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1375 current_event
.dwThreadId
,
1379 error (_("Failed to resume program execution"
1380 " (ContinueDebugEvent failed, error %u)"),
1381 (unsigned int) GetLastError ());
1383 debug_registers_changed
= 0;
1387 /* Called in pathological case where Windows fails to send a
1388 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1390 fake_create_process (void)
1392 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1393 current_event
.dwProcessId
);
1394 if (current_process_handle
!= NULL
)
1395 open_process_used
= 1;
1398 error (_("OpenProcess call failed, GetLastError = %u"),
1399 (unsigned) GetLastError ());
1400 /* We can not debug anything in that case. */
1403 = windows_add_thread (ptid_t (current_event
.dwProcessId
, 0,
1404 current_event
.dwThreadId
),
1405 current_event
.u
.CreateThread
.hThread
,
1406 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1407 true /* main_thread_p */);
1408 return current_event
.dwThreadId
;
1412 windows_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1414 windows_thread_info
*th
;
1415 DWORD continue_status
= DBG_CONTINUE
;
1417 /* A specific PTID means `step only this thread id'. */
1418 int resume_all
= ptid
== minus_one_ptid
;
1420 /* If we're continuing all threads, it's the current inferior that
1421 should be handled specially. */
1423 ptid
= inferior_ptid
;
1425 if (sig
!= GDB_SIGNAL_0
)
1427 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1429 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1431 else if (sig
== last_sig
)
1432 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1435 /* This code does not seem to work, because
1436 the kernel does probably not consider changes in the ExceptionRecord
1437 structure when passing the exception to the inferior.
1438 Note that this seems possible in the exception handler itself. */
1440 for (const xlate_exception
&x
: xlate
)
1443 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1445 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1448 if (continue_status
== DBG_CONTINUE
)
1450 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1454 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1458 last_sig
= GDB_SIGNAL_0
;
1460 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
1461 ptid
.pid (), (unsigned) ptid
.tid (), step
, sig
));
1463 /* Get context for currently selected thread. */
1464 th
= thread_rec (inferior_ptid
.tid (), FALSE
);
1469 /* Single step by setting t bit. */
1470 struct regcache
*regcache
= get_current_regcache ();
1471 struct gdbarch
*gdbarch
= regcache
->arch ();
1472 fetch_registers (regcache
, gdbarch_ps_regnum (gdbarch
));
1473 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1476 if (th
->context
.ContextFlags
)
1478 if (debug_registers_changed
)
1480 th
->context
.Dr0
= dr
[0];
1481 th
->context
.Dr1
= dr
[1];
1482 th
->context
.Dr2
= dr
[2];
1483 th
->context
.Dr3
= dr
[3];
1484 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1485 th
->context
.Dr7
= dr
[7];
1487 CHECK (SetThreadContext (th
->h
, &th
->context
));
1488 th
->context
.ContextFlags
= 0;
1492 /* Allow continuing with the same signal that interrupted us.
1493 Otherwise complain. */
1496 windows_continue (continue_status
, -1, 0);
1498 windows_continue (continue_status
, ptid
.tid (), 0);
1501 /* Ctrl-C handler used when the inferior is not run in the same console. The
1502 handler is in charge of interrupting the inferior using DebugBreakProcess.
1503 Note that this function is not available prior to Windows XP. In this case
1504 we emit a warning. */
1506 ctrl_c_handler (DWORD event_type
)
1508 const int attach_flag
= current_inferior ()->attach_flag
;
1510 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1511 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1514 /* If the inferior and the debugger share the same console, do nothing as
1515 the inferior has also received the Ctrl-C event. */
1516 if (!new_console
&& !attach_flag
)
1519 if (!DebugBreakProcess (current_process_handle
))
1520 warning (_("Could not interrupt program. "
1521 "Press Ctrl-c in the program console."));
1523 /* Return true to tell that Ctrl-C has been handled. */
1527 /* Get the next event from the child. Returns a non-zero thread id if the event
1528 requires handling by WFI (or whatever). */
1531 windows_nat_target::get_windows_debug_event (int pid
,
1532 struct target_waitstatus
*ourstatus
)
1535 DWORD continue_status
, event_code
;
1536 windows_thread_info
*th
;
1537 static windows_thread_info dummy_thread_info
;
1538 DWORD thread_id
= 0;
1540 last_sig
= GDB_SIGNAL_0
;
1542 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1546 continue_status
= DBG_CONTINUE
;
1548 event_code
= current_event
.dwDebugEventCode
;
1549 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1551 have_saved_context
= 0;
1555 case CREATE_THREAD_DEBUG_EVENT
:
1556 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1557 (unsigned) current_event
.dwProcessId
,
1558 (unsigned) current_event
.dwThreadId
,
1559 "CREATE_THREAD_DEBUG_EVENT"));
1560 if (saw_create
!= 1)
1562 inferior
*inf
= find_inferior_pid (this, current_event
.dwProcessId
);
1563 if (!saw_create
&& inf
->attach_flag
)
1565 /* Kludge around a Windows bug where first event is a create
1566 thread event. Caused when attached process does not have
1568 thread_id
= fake_create_process ();
1574 /* Record the existence of this thread. */
1575 thread_id
= current_event
.dwThreadId
;
1576 th
= windows_add_thread
1577 (ptid_t (current_event
.dwProcessId
, 0, current_event
.dwThreadId
),
1578 current_event
.u
.CreateThread
.hThread
,
1579 current_event
.u
.CreateThread
.lpThreadLocalBase
,
1580 false /* main_thread_p */);
1584 case EXIT_THREAD_DEBUG_EVENT
:
1585 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1586 (unsigned) current_event
.dwProcessId
,
1587 (unsigned) current_event
.dwThreadId
,
1588 "EXIT_THREAD_DEBUG_EVENT"));
1589 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1590 current_event
.dwThreadId
),
1591 current_event
.u
.ExitThread
.dwExitCode
,
1592 false /* main_thread_p */);
1593 th
= &dummy_thread_info
;
1596 case CREATE_PROCESS_DEBUG_EVENT
:
1597 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1598 (unsigned) current_event
.dwProcessId
,
1599 (unsigned) current_event
.dwThreadId
,
1600 "CREATE_PROCESS_DEBUG_EVENT"));
1601 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1602 if (++saw_create
!= 1)
1605 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1606 /* Add the main thread. */
1607 th
= windows_add_thread
1608 (ptid_t (current_event
.dwProcessId
, 0,
1609 current_event
.dwThreadId
),
1610 current_event
.u
.CreateProcessInfo
.hThread
,
1611 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
,
1612 true /* main_thread_p */);
1613 thread_id
= current_event
.dwThreadId
;
1616 case EXIT_PROCESS_DEBUG_EVENT
:
1617 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1618 (unsigned) current_event
.dwProcessId
,
1619 (unsigned) current_event
.dwThreadId
,
1620 "EXIT_PROCESS_DEBUG_EVENT"));
1621 if (!windows_initialization_done
)
1623 target_terminal::ours ();
1624 target_mourn_inferior (inferior_ptid
);
1625 error (_("During startup program exited with code 0x%x."),
1626 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1628 else if (saw_create
== 1)
1630 windows_delete_thread (ptid_t (current_event
.dwProcessId
, 0,
1631 current_event
.dwThreadId
),
1632 0, true /* main_thread_p */);
1633 DWORD exit_status
= current_event
.u
.ExitProcess
.dwExitCode
;
1634 /* If the exit status looks like a fatal exception, but we
1635 don't recognize the exception's code, make the original
1636 exit status value available, to avoid losing
1639 = WIFSIGNALED (exit_status
) ? WTERMSIG (exit_status
) : -1;
1640 if (exit_signal
== -1)
1642 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1643 ourstatus
->value
.integer
= exit_status
;
1647 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1648 ourstatus
->value
.sig
= gdb_signal_from_host (exit_signal
);
1650 thread_id
= current_event
.dwThreadId
;
1654 case LOAD_DLL_DEBUG_EVENT
:
1655 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1656 (unsigned) current_event
.dwProcessId
,
1657 (unsigned) current_event
.dwThreadId
,
1658 "LOAD_DLL_DEBUG_EVENT"));
1659 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1660 if (saw_create
!= 1 || ! windows_initialization_done
)
1662 catch_errors (handle_load_dll
);
1663 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1664 ourstatus
->value
.integer
= 0;
1665 thread_id
= current_event
.dwThreadId
;
1668 case UNLOAD_DLL_DEBUG_EVENT
:
1669 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1670 (unsigned) current_event
.dwProcessId
,
1671 (unsigned) current_event
.dwThreadId
,
1672 "UNLOAD_DLL_DEBUG_EVENT"));
1673 if (saw_create
!= 1 || ! windows_initialization_done
)
1675 catch_errors (handle_unload_dll
);
1676 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1677 ourstatus
->value
.integer
= 0;
1678 thread_id
= current_event
.dwThreadId
;
1681 case EXCEPTION_DEBUG_EVENT
:
1682 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1683 (unsigned) current_event
.dwProcessId
,
1684 (unsigned) current_event
.dwThreadId
,
1685 "EXCEPTION_DEBUG_EVENT"));
1686 if (saw_create
!= 1)
1688 switch (handle_exception (ourstatus
))
1690 case HANDLE_EXCEPTION_UNHANDLED
:
1692 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1694 case HANDLE_EXCEPTION_HANDLED
:
1695 thread_id
= current_event
.dwThreadId
;
1697 case HANDLE_EXCEPTION_IGNORED
:
1698 continue_status
= DBG_CONTINUE
;
1703 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1704 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1705 (unsigned) current_event
.dwProcessId
,
1706 (unsigned) current_event
.dwThreadId
,
1707 "OUTPUT_DEBUG_STRING_EVENT"));
1708 if (saw_create
!= 1)
1710 thread_id
= handle_output_debug_string (ourstatus
);
1714 if (saw_create
!= 1)
1716 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1717 (unsigned) current_event
.dwProcessId
,
1718 (unsigned) current_event
.dwThreadId
);
1719 printf_unfiltered (" unknown event code %u\n",
1720 (unsigned) current_event
.dwDebugEventCode
);
1724 if (!thread_id
|| saw_create
!= 1)
1726 CHECK (windows_continue (continue_status
, -1, 0));
1730 inferior_ptid
= ptid_t (current_event
.dwProcessId
, 0, thread_id
);
1731 current_thread
= th
;
1732 if (!current_thread
)
1733 current_thread
= thread_rec (thread_id
, TRUE
);
1740 /* Wait for interesting events to occur in the target process. */
1742 windows_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1747 /* We loop when we get a non-standard exception rather than return
1748 with a SPURIOUS because resume can try and step or modify things,
1749 which needs a current_thread->h. But some of these exceptions mark
1750 the birth or death of threads, which mean that the current thread
1751 isn't necessarily what you think it is. */
1757 /* If the user presses Ctrl-c while the debugger is waiting
1758 for an event, he expects the debugger to interrupt his program
1759 and to get the prompt back. There are two possible situations:
1761 - The debugger and the program do not share the console, in
1762 which case the Ctrl-c event only reached the debugger.
1763 In that case, the ctrl_c handler will take care of interrupting
1764 the inferior. Note that this case is working starting with
1765 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1768 - The debugger and the program share the same console, in which
1769 case both debugger and inferior will receive the Ctrl-c event.
1770 In that case the ctrl_c handler will ignore the event, as the
1771 Ctrl-c event generated inside the inferior will trigger the
1772 expected debug event.
1774 FIXME: brobecker/2008-05-20: If the inferior receives the
1775 signal first and the delay until GDB receives that signal
1776 is sufficiently long, GDB can sometimes receive the SIGINT
1777 after we have unblocked the CTRL+C handler. This would
1778 lead to the debugger stopping prematurely while handling
1779 the new-thread event that comes with the handling of the SIGINT
1780 inside the inferior, and then stop again immediately when
1781 the user tries to resume the execution in the inferior.
1782 This is a classic race that we should try to fix one day. */
1783 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1784 retval
= get_windows_debug_event (pid
, ourstatus
);
1785 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1788 return ptid_t (current_event
.dwProcessId
, 0, retval
);
1793 if (deprecated_ui_loop_hook
!= NULL
)
1794 detach
= deprecated_ui_loop_hook (0);
1802 /* Iterate over all DLLs currently mapped by our inferior, and
1803 add them to our list of solibs. */
1806 windows_add_all_dlls (void)
1808 HMODULE dummy_hmodule
;
1813 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1814 sizeof (HMODULE
), &cb_needed
) == 0)
1820 hmodules
= (HMODULE
*) alloca (cb_needed
);
1821 if (EnumProcessModules (current_process_handle
, hmodules
,
1822 cb_needed
, &cb_needed
) == 0)
1825 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1829 wchar_t dll_name
[__PMAX
];
1832 char dll_name
[__PMAX
];
1835 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1836 &mi
, sizeof (mi
)) == 0)
1838 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1839 dll_name
, sizeof (dll_name
)) == 0)
1842 wcstombs (name
, dll_name
, __PMAX
);
1847 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1848 solib_end
= solib_end
->next
;
1853 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1856 struct inferior
*inf
;
1858 last_sig
= GDB_SIGNAL_0
;
1860 exception_count
= 0;
1861 open_process_used
= 0;
1862 debug_registers_changed
= 0;
1863 debug_registers_used
= 0;
1864 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1867 cygwin_load_start
= cygwin_load_end
= 0;
1869 current_event
.dwProcessId
= pid
;
1870 memset (¤t_event
, 0, sizeof (current_event
));
1871 if (!target_is_pushed (ops
))
1873 disable_breakpoints_in_shlibs ();
1874 windows_clear_solib ();
1875 clear_proceed_status (0);
1876 init_wait_for_inferior ();
1878 inf
= current_inferior ();
1879 inferior_appeared (inf
, pid
);
1880 inf
->attach_flag
= attaching
;
1882 /* Make the new process the current inferior, so terminal handling
1883 can rely on it. When attaching, we don't know about any thread
1884 id here, but that's OK --- nothing should be referencing the
1885 current thread until we report an event out of windows_wait. */
1886 inferior_ptid
= ptid_t (pid
);
1888 target_terminal::init ();
1889 target_terminal::inferior ();
1891 windows_initialization_done
= 0;
1895 struct target_waitstatus status
;
1897 ops
->wait (minus_one_ptid
, &status
, 0);
1899 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1901 if (status
.kind
!= TARGET_WAITKIND_LOADED
1902 && status
.kind
!= TARGET_WAITKIND_SPURIOUS
)
1905 ops
->resume (minus_one_ptid
, 0, GDB_SIGNAL_0
);
1908 /* Now that the inferior has been started and all DLLs have been mapped,
1909 we can iterate over all DLLs and load them in.
1911 We avoid doing it any earlier because, on certain versions of Windows,
1912 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1913 we have seen on Windows 8.1 that the ntdll.dll load event does not
1914 include the DLL name, preventing us from creating an associated SO.
1915 A possible explanation is that ntdll.dll might be mapped before
1916 the SO info gets created by the Windows system -- ntdll.dll is
1917 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1918 do not seem to suffer from that problem.
1920 Rather than try to work around this sort of issue, it is much
1921 simpler to just ignore DLL load/unload events during the startup
1922 phase, and then process them all in one batch now. */
1923 windows_add_all_dlls ();
1925 windows_initialization_done
= 1;
1929 /* Try to set or remove a user privilege to the current process. Return -1
1930 if that fails, the previous setting of that privilege otherwise.
1932 This code is copied from the Cygwin source code and rearranged to allow
1933 dynamically loading of the needed symbols from advapi32 which is only
1934 available on NT/2K/XP. */
1936 set_process_privilege (const char *privilege
, BOOL enable
)
1938 HANDLE token_hdl
= NULL
;
1940 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1944 if (!OpenProcessToken (GetCurrentProcess (),
1945 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1949 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1952 new_priv
.PrivilegeCount
= 1;
1953 new_priv
.Privileges
[0].Luid
= restore_priv
;
1954 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1956 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1957 sizeof orig_priv
, &orig_priv
, &size
))
1960 /* Disabled, otherwise every `attach' in an unprivileged user session
1961 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1962 windows_attach(). */
1963 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1964 be enabled. GetLastError () returns an correct error code, though. */
1965 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1969 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1973 CloseHandle (token_hdl
);
1978 /* Attach to process PID, then initialize for debugging it. */
1981 windows_nat_target::attach (const char *args
, int from_tty
)
1986 pid
= parse_pid_to_attach (args
);
1988 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1990 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1991 printf_unfiltered ("This can cause attach to "
1992 "fail on Windows NT/2K/XP\n");
1995 windows_init_thread_list ();
1996 ok
= DebugActiveProcess (pid
);
2002 /* Try fall back to Cygwin pid. */
2003 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
2006 ok
= DebugActiveProcess (pid
);
2011 error (_("Can't attach to process %u (error %u)"),
2012 (unsigned) pid
, (unsigned) GetLastError ());
2014 DebugSetProcessKillOnExit (FALSE
);
2018 const char *exec_file
= get_exec_file (0);
2021 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
2022 target_pid_to_str (ptid_t (pid
)).c_str ());
2024 printf_unfiltered ("Attaching to %s\n",
2025 target_pid_to_str (ptid_t (pid
)).c_str ());
2028 do_initial_windows_stuff (this, pid
, 1);
2029 target_terminal::ours ();
2033 windows_nat_target::detach (inferior
*inf
, int from_tty
)
2037 ptid_t ptid
= minus_one_ptid
;
2038 resume (ptid
, 0, GDB_SIGNAL_0
);
2040 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
2042 error (_("Can't detach process %u (error %u)"),
2043 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
2046 DebugSetProcessKillOnExit (FALSE
);
2048 if (detached
&& from_tty
)
2050 const char *exec_file
= get_exec_file (0);
2053 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
2054 (unsigned) current_event
.dwProcessId
);
2057 x86_cleanup_dregs ();
2058 inferior_ptid
= null_ptid
;
2059 detach_inferior (inf
);
2061 maybe_unpush_target ();
2064 /* Try to determine the executable filename.
2066 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2068 Upon success, the filename is stored inside EXE_NAME_RET, and
2069 this function returns nonzero.
2071 Otherwise, this function returns zero and the contents of
2072 EXE_NAME_RET is undefined. */
2075 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
2082 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
2083 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
2086 /* We know the executable is always first in the list of modules,
2087 which we just fetched. So no need to fetch more. */
2091 /* Cygwin prefers that the path be in /x/y/z format, so extract
2092 the filename into a temporary buffer first, and then convert it
2093 to POSIX format into the destination buffer. */
2094 cygwin_buf_t
*pathbuf
= (cygwin_buf_t
*) alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
2096 len
= GetModuleFileNameEx (current_process_handle
,
2097 dh_buf
, pathbuf
, exe_name_max_len
);
2099 error (_("Error getting executable filename: %u."),
2100 (unsigned) GetLastError ());
2101 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
2102 exe_name_max_len
) < 0)
2103 error (_("Error converting executable filename to POSIX: %d."), errno
);
2106 len
= GetModuleFileNameEx (current_process_handle
,
2107 dh_buf
, exe_name_ret
, exe_name_max_len
);
2109 error (_("Error getting executable filename: %u."),
2110 (unsigned) GetLastError ());
2113 return 1; /* success */
2116 /* The pid_to_exec_file target_ops method for this platform. */
2119 windows_nat_target::pid_to_exec_file (int pid
)
2121 static char path
[__PMAX
];
2123 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2125 char procexe
[sizeof ("/proc/4294967295/exe")];
2127 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
2128 nchars
= readlink (procexe
, path
, sizeof(path
));
2129 if (nchars
> 0 && nchars
< sizeof (path
))
2131 path
[nchars
] = '\0'; /* Got it */
2136 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2137 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2138 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2144 /* Print status information about what we're accessing. */
2147 windows_nat_target::files_info ()
2149 struct inferior
*inf
= current_inferior ();
2151 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2152 inf
->attach_flag
? "attached" : "child",
2153 target_pid_to_str (inferior_ptid
).c_str ());
2156 /* Modify CreateProcess parameters for use of a new separate console.
2158 *FLAGS: DWORD parameter for general process creation flags.
2159 *SI: STARTUPINFO structure, for which the console window size and
2160 console buffer size is filled in if GDB is running in a console.
2161 to create the new console.
2162 The size of the used font is not available on all versions of
2163 Windows OS. Furthermore, the current font might not be the default
2164 font, but this is still better than before.
2165 If the windows and buffer sizes are computed,
2166 SI->DWFLAGS is changed so that this information is used
2167 by CreateProcess function. */
2170 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2172 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2173 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2175 if (hconsole
!= INVALID_HANDLE_VALUE
)
2177 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2179 CONSOLE_FONT_INFO cfi
;
2181 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2182 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2183 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2184 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2185 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2187 si
->dwXSize
*= font_size
.X
;
2191 si
->dwYSize
*= font_size
.Y
;
2194 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2195 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2196 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2198 *flags
|= CREATE_NEW_CONSOLE
;
2202 /* Function called by qsort to sort environment strings. */
2205 envvar_cmp (const void *a
, const void *b
)
2207 const char **p
= (const char **) a
;
2208 const char **q
= (const char **) b
;
2209 return strcasecmp (*p
, *q
);
2215 clear_win32_environment (char **env
)
2219 wchar_t *copy
= NULL
, *equalpos
;
2221 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2223 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2224 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2225 mbstowcs (copy
, env
[i
], len
);
2226 equalpos
= wcschr (copy
, L
'=');
2229 SetEnvironmentVariableW (copy
, NULL
);
2237 /* Redirection of inferior I/O streams for native MS-Windows programs.
2238 Unlike on Unix, where this is handled by invoking the inferior via
2239 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2241 The official documentation of the cmd.exe redirection features is here:
2243 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2245 (That page talks about Windows XP, but there's no newer
2246 documentation, so we assume later versions of cmd.exe didn't change
2249 Caveat: the documentation on that page seems to include a few lies.
2250 For example, it describes strange constructs 1<&2 and 2<&1, which
2251 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2252 think the cmd.exe parser of the redirection symbols simply doesn't
2253 care about the < vs > distinction in these cases. Therefore, the
2254 supported features are explicitly documented below.
2256 The emulation below aims at supporting all the valid use cases
2257 supported by cmd.exe, which include:
2259 < FILE redirect standard input from FILE
2260 0< FILE redirect standard input from FILE
2261 <&N redirect standard input from file descriptor N
2262 0<&N redirect standard input from file descriptor N
2263 > FILE redirect standard output to FILE
2264 >> FILE append standard output to FILE
2265 1>> FILE append standard output to FILE
2266 >&N redirect standard output to file descriptor N
2267 1>&N redirect standard output to file descriptor N
2268 >>&N append standard output to file descriptor N
2269 1>>&N append standard output to file descriptor N
2270 2> FILE redirect standard error to FILE
2271 2>> FILE append standard error to FILE
2272 2>&N redirect standard error to file descriptor N
2273 2>>&N append standard error to file descriptor N
2275 Note that using N > 2 in the above construct is supported, but
2276 requires that the corresponding file descriptor be open by some
2277 means elsewhere or outside GDB. Also note that using ">&0" or
2278 "<&2" will generally fail, because the file descriptor redirected
2279 from is normally open in an incompatible mode (e.g., FD 0 is open
2280 for reading only). IOW, use of such tricks is not recommended;
2281 you are on your own.
2283 We do NOT support redirection of file descriptors above 2, as in
2284 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2285 that needs special handling in the startup code that MinGW
2286 doesn't have). Pipes are also not supported.
2288 As for invalid use cases, where the redirection contains some
2289 error, the emulation below will detect that and produce some
2290 error and/or failure. But the behavior in those cases is not
2291 bug-for-bug compatible with what cmd.exe does in those cases.
2292 That's because what cmd.exe does then is not well defined, and
2293 seems to be a side effect of the cmd.exe parsing of the command
2294 line more than anything else. For example, try redirecting to an
2295 invalid file name, as in "> foo:bar".
2297 There are also minor syntactic deviations from what cmd.exe does
2298 in some corner cases. For example, it doesn't support the likes
2299 of "> &foo" to mean redirect to file named literally "&foo"; we
2300 do support that here, because that, too, sounds like some issue
2301 with the cmd.exe parser. Another nicety is that we support
2302 redirection targets that use file names with forward slashes,
2303 something cmd.exe doesn't -- this comes in handy since GDB
2304 file-name completion can be used when typing the command line for
2307 /* Support routines for redirecting standard handles of the inferior. */
2309 /* Parse a single redirection spec, open/duplicate the specified
2310 file/fd, and assign the appropriate value to one of the 3 standard
2311 file descriptors. */
2313 redir_open (const char *redir_string
, int *inp
, int *out
, int *err
)
2315 int *fd
, ref_fd
= -2;
2317 const char *fname
= redir_string
+ 1;
2318 int rc
= *redir_string
;
2333 fd
= (rc
== '2') ? err
: out
;
2334 mode
= O_WRONLY
| O_CREAT
;
2347 if (*fname
== '&' && '0' <= fname
[1] && fname
[1] <= '9')
2349 /* A reference to a file descriptor. */
2351 ref_fd
= (int) strtol (fname
+ 1, &fdtail
, 10);
2352 if (fdtail
> fname
+ 1 && *fdtail
== '\0')
2354 /* Don't allow redirection when open modes are incompatible. */
2355 if ((ref_fd
== 0 && (fd
== out
|| fd
== err
))
2356 || ((ref_fd
== 1 || ref_fd
== 2) && fd
== inp
))
2363 else if (ref_fd
== 1)
2365 else if (ref_fd
== 2)
2375 fname
++; /* skip the separator space */
2376 /* If the descriptor is already open, close it. This allows
2377 multiple specs of redirections for the same stream, which is
2378 somewhat nonsensical, but still valid and supported by cmd.exe.
2379 (But cmd.exe only opens a single file in this case, the one
2380 specified by the last redirection spec on the command line.) */
2385 *fd
= _open (fname
, mode
, _S_IREAD
| _S_IWRITE
);
2389 else if (ref_fd
== -1)
2390 *fd
= -1; /* reset to default destination */
2393 *fd
= _dup (ref_fd
);
2397 /* _open just sets a flag for O_APPEND, which won't be passed to the
2398 inferior, so we need to actually move the file pointer. */
2399 if ((mode
& O_APPEND
) != 0)
2400 _lseek (*fd
, 0L, SEEK_END
);
2404 /* Canonicalize a single redirection spec and set up the corresponding
2405 file descriptor as specified. */
2407 redir_set_redirection (const char *s
, int *inp
, int *out
, int *err
)
2409 char buf
[__PMAX
+ 2 + 5]; /* extra space for quotes & redirection string */
2411 const char *start
= s
;
2414 *d
++ = *s
++; /* copy the 1st character, < or > or a digit */
2415 if ((*start
== '>' || *start
== '1' || *start
== '2')
2419 if (*s
== '>' && *start
!= '>')
2422 else if (*start
== '0' && *s
== '<')
2424 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2427 while (isspace (*s
)) /* skip whitespace before file name */
2429 *d
++ = ' '; /* separate file name with a single space */
2432 /* Copy the file name. */
2435 /* Remove quoting characters from the file name in buf[]. */
2436 if (*s
== '"') /* could support '..' quoting here */
2440 else if (*s
== quote
)
2448 else if (*s
== '\\')
2450 if (s
[1] == '"') /* could support '..' here */
2454 else if (isspace (*s
) && !quote
)
2458 if (d
- buf
>= sizeof (buf
) - 1)
2460 errno
= ENAMETOOLONG
;
2466 /* Windows doesn't allow redirection characters in file names, so we
2467 can bail out early if they use them, or if there's no target file
2468 name after the redirection symbol. */
2469 if (d
[-1] == '>' || d
[-1] == '<')
2474 if (redir_open (buf
, inp
, out
, err
) == 0)
2479 /* Parse the command line for redirection specs and prepare the file
2480 descriptors for the 3 standard streams accordingly. */
2482 redirect_inferior_handles (const char *cmd_orig
, char *cmd
,
2483 int *inp
, int *out
, int *err
)
2485 const char *s
= cmd_orig
;
2488 bool retval
= false;
2490 while (isspace (*s
))
2495 if (*s
== '"') /* could also support '..' quoting here */
2499 else if (*s
== quote
)
2502 else if (*s
== '\\')
2504 if (s
[1] == '"') /* escaped quote char */
2509 /* Process a single redirection candidate. */
2510 if (*s
== '<' || *s
== '>'
2511 || ((*s
== '1' || *s
== '2') && s
[1] == '>')
2512 || (*s
== '0' && s
[1] == '<'))
2514 int skip
= redir_set_redirection (s
, inp
, out
, err
);
2528 #endif /* !__CYGWIN__ */
2530 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2531 EXEC_FILE is the file to run.
2532 ALLARGS is a string containing the arguments to the program.
2533 ENV is the environment vector to pass. Errors reported with error(). */
2536 windows_nat_target::create_inferior (const char *exec_file
,
2537 const std::string
&origallargs
,
2538 char **in_env
, int from_tty
)
2542 cygwin_buf_t real_path
[__PMAX
];
2543 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2544 cygwin_buf_t infcwd
[__PMAX
];
2546 cygwin_buf_t
*toexec
;
2547 cygwin_buf_t
*cygallargs
;
2549 char **old_env
= NULL
;
2553 int ostdin
, ostdout
, ostderr
;
2554 #else /* !__CYGWIN__ */
2555 char shell
[__PMAX
]; /* Path to shell */
2557 char *args
, *allargs_copy
;
2558 size_t args_len
, allargs_len
;
2559 int fd_inp
= -1, fd_out
= -1, fd_err
= -1;
2560 HANDLE tty
= INVALID_HANDLE_VALUE
;
2561 bool redirected
= false;
2568 #endif /* !__CYGWIN__ */
2569 const char *allargs
= origallargs
.c_str ();
2570 PROCESS_INFORMATION pi
;
2573 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2576 error (_("No executable specified, use `target exec'."));
2578 const char *inferior_cwd
= get_inferior_cwd ();
2579 std::string expanded_infcwd
;
2580 if (inferior_cwd
!= NULL
)
2582 expanded_infcwd
= gdb_tilde_expand (inferior_cwd
);
2583 /* Mirror slashes on inferior's cwd. */
2584 std::replace (expanded_infcwd
.begin (), expanded_infcwd
.end (),
2586 inferior_cwd
= expanded_infcwd
.c_str ();
2589 memset (&si
, 0, sizeof (si
));
2590 si
.cb
= sizeof (si
);
2593 flags
|= CREATE_NEW_PROCESS_GROUP
;
2596 windows_set_console_info (&si
, &flags
);
2601 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2602 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2603 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2604 error (_("Error starting executable: %d"), errno
);
2607 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2608 if (len
== (size_t) -1)
2609 error (_("Error starting executable: %d"), errno
);
2610 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2611 mbstowcs (cygallargs
, allargs
, len
);
2612 #else /* !__USEWIDE */
2613 cygallargs
= allargs
;
2619 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2620 error (_("Error starting executable via shell: %d"), errno
);
2622 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2623 + mbstowcs (NULL
, allargs
, 0) + 2;
2624 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2625 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2626 #else /* !__USEWIDE */
2627 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2628 + strlen (allargs
) + 2);
2629 cygallargs
= (char *) alloca (len
);
2630 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2631 #endif /* __USEWIDE */
2633 flags
|= DEBUG_PROCESS
;
2636 if (inferior_cwd
!= NULL
2637 && cygwin_conv_path (CCP_POSIX_TO_WIN_W
, inferior_cwd
,
2638 infcwd
, strlen (inferior_cwd
)) < 0)
2639 error (_("Error converting inferior cwd: %d"), errno
);
2642 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2643 * sizeof (wchar_t));
2644 wcscpy (args
, toexec
);
2645 wcscat (args
, L
" ");
2646 wcscat (args
, cygallargs
);
2647 #else /* !__USEWIDE */
2648 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2649 strcpy (args
, toexec
);
2651 strcat (args
, cygallargs
);
2652 #endif /* !__USEWIDE */
2654 #ifdef CW_CVT_ENV_TO_WINENV
2655 /* First try to create a direct Win32 copy of the POSIX environment. */
2656 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2657 if (w32_env
!= (PWCHAR
) -1)
2658 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2660 /* If that fails, fall back to old method tweaking GDB's environment. */
2661 #endif /* CW_CVT_ENV_TO_WINENV */
2663 /* Reset all Win32 environment variables to avoid leftover on next run. */
2664 clear_win32_environment (environ
);
2665 /* Prepare the environment vars for CreateProcess. */
2668 cygwin_internal (CW_SYNC_WINENV
);
2672 if (!inferior_io_terminal
)
2673 tty
= ostdin
= ostdout
= ostderr
= -1;
2676 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2679 print_sys_errmsg (inferior_io_terminal
, errno
);
2680 ostdin
= ostdout
= ostderr
= -1;
2693 windows_init_thread_list ();
2694 ret
= CreateProcess (0,
2695 args
, /* command line */
2696 NULL
, /* Security */
2698 TRUE
, /* inherit handles */
2699 flags
, /* start flags */
2700 w32_env
, /* environment */
2701 inferior_cwd
!= NULL
? infcwd
: NULL
, /* current
2706 /* Just free the Win32 environment, if it could be created. */
2710 /* Reset all environment variables to avoid leftover on next run. */
2711 clear_win32_environment (in_env
);
2712 /* Restore normal GDB environment variables. */
2714 cygwin_internal (CW_SYNC_WINENV
);
2727 #else /* !__CYGWIN__ */
2728 allargs_len
= strlen (allargs
);
2729 allargs_copy
= strcpy ((char *) alloca (allargs_len
+ 1), allargs
);
2730 if (strpbrk (allargs_copy
, "<>") != NULL
)
2735 redirect_inferior_handles (allargs
, allargs_copy
,
2736 &fd_inp
, &fd_out
, &fd_err
);
2738 warning (_("Error in redirection: %s."), safe_strerror (errno
));
2741 allargs_len
= strlen (allargs_copy
);
2743 /* If not all the standard streams are redirected by the command
2744 line, use inferior_io_terminal for those which aren't. */
2745 if (inferior_io_terminal
2746 && !(fd_inp
>= 0 && fd_out
>= 0 && fd_err
>= 0))
2748 SECURITY_ATTRIBUTES sa
;
2749 sa
.nLength
= sizeof(sa
);
2750 sa
.lpSecurityDescriptor
= 0;
2751 sa
.bInheritHandle
= TRUE
;
2752 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2753 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2754 if (tty
== INVALID_HANDLE_VALUE
)
2755 warning (_("Warning: Failed to open TTY %s, error %#x."),
2756 inferior_io_terminal
, (unsigned) GetLastError ());
2758 if (redirected
|| tty
!= INVALID_HANDLE_VALUE
)
2761 si
.hStdInput
= (HANDLE
) _get_osfhandle (fd_inp
);
2762 else if (tty
!= INVALID_HANDLE_VALUE
)
2765 si
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
2767 si
.hStdOutput
= (HANDLE
) _get_osfhandle (fd_out
);
2768 else if (tty
!= INVALID_HANDLE_VALUE
)
2769 si
.hStdOutput
= tty
;
2771 si
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
2773 si
.hStdError
= (HANDLE
) _get_osfhandle (fd_err
);
2774 else if (tty
!= INVALID_HANDLE_VALUE
)
2777 si
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
2778 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2782 /* Build the command line, a space-separated list of tokens where
2783 the first token is the name of the module to be executed.
2784 To avoid ambiguities introduced by spaces in the module name,
2786 args_len
= strlen (toexec
) + 2 /* quotes */ + allargs_len
+ 2;
2787 args
= (char *) alloca (args_len
);
2788 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs_copy
);
2790 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2792 /* CreateProcess takes the environment list as a null terminated set of
2793 strings (i.e. two nulls terminate the list). */
2795 /* Get total size for env strings. */
2796 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2797 envlen
+= strlen (in_env
[i
]) + 1;
2799 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2800 env
= (char **) alloca (envsize
);
2801 memcpy (env
, in_env
, envsize
);
2802 /* Windows programs expect the environment block to be sorted. */
2803 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2805 w32env
= (char *) alloca (envlen
+ 1);
2807 /* Copy env strings into new buffer. */
2808 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2810 strcpy (temp
, env
[i
]);
2811 temp
+= strlen (temp
) + 1;
2814 /* Final nil string to terminate new env. */
2817 windows_init_thread_list ();
2818 ret
= CreateProcessA (0,
2819 args
, /* command line */
2820 NULL
, /* Security */
2822 TRUE
, /* inherit handles */
2823 flags
, /* start flags */
2824 w32env
, /* environment */
2825 inferior_cwd
, /* current directory */
2828 if (tty
!= INVALID_HANDLE_VALUE
)
2836 #endif /* !__CYGWIN__ */
2839 error (_("Error creating process %s, (error %u)."),
2840 exec_file
, (unsigned) GetLastError ());
2842 CloseHandle (pi
.hThread
);
2843 CloseHandle (pi
.hProcess
);
2845 if (useshell
&& shell
[0] != '\0')
2850 do_initial_windows_stuff (this, pi
.dwProcessId
, 0);
2852 /* windows_continue (DBG_CONTINUE, -1, 0); */
2856 windows_nat_target::mourn_inferior ()
2858 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2859 x86_cleanup_dregs();
2860 if (open_process_used
)
2862 CHECK (CloseHandle (current_process_handle
));
2863 open_process_used
= 0;
2865 inf_child_target::mourn_inferior ();
2868 /* Send a SIGINT to the process group. This acts just like the user typed a
2869 ^C on the controlling terminal. */
2872 windows_nat_target::interrupt ()
2874 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2875 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2876 registers_changed (); /* refresh register state */
2879 /* Helper for windows_xfer_partial that handles memory transfers.
2880 Arguments are like target_xfer_partial. */
2882 static enum target_xfer_status
2883 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2884 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2888 DWORD lasterror
= 0;
2890 if (writebuf
!= NULL
)
2892 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2893 pulongest (len
), core_addr_to_string (memaddr
)));
2894 success
= WriteProcessMemory (current_process_handle
,
2895 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2898 lasterror
= GetLastError ();
2899 FlushInstructionCache (current_process_handle
,
2900 (LPCVOID
) (uintptr_t) memaddr
, len
);
2904 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2905 pulongest (len
), core_addr_to_string (memaddr
)));
2906 success
= ReadProcessMemory (current_process_handle
,
2907 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2910 lasterror
= GetLastError ();
2912 *xfered_len
= (ULONGEST
) done
;
2913 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2914 return TARGET_XFER_OK
;
2916 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2920 windows_nat_target::kill ()
2922 CHECK (TerminateProcess (current_process_handle
, 0));
2926 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2928 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2930 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2934 target_mourn_inferior (inferior_ptid
); /* Or just windows_mourn_inferior? */
2938 windows_nat_target::close ()
2940 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2941 inferior_ptid
.pid ()));
2944 /* Convert pid to printable format. */
2946 windows_nat_target::pid_to_str (ptid_t ptid
)
2948 if (ptid
.tid () != 0)
2949 return string_printf ("Thread %d.0x%lx", ptid
.pid (), ptid
.tid ());
2951 return normal_pid_to_str (ptid
);
2954 static enum target_xfer_status
2955 windows_xfer_shared_libraries (struct target_ops
*ops
,
2956 enum target_object object
, const char *annex
,
2957 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2958 ULONGEST offset
, ULONGEST len
,
2959 ULONGEST
*xfered_len
)
2961 struct obstack obstack
;
2967 return TARGET_XFER_E_IO
;
2969 obstack_init (&obstack
);
2970 obstack_grow_str (&obstack
, "<library-list>\n");
2971 for (so
= solib_start
.next
; so
; so
= so
->next
)
2973 lm_info_windows
*li
= (lm_info_windows
*) so
->lm_info
;
2975 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2976 (uintptr_t) li
->load_addr
,
2977 target_gdbarch (), &obstack
);
2979 obstack_grow_str0 (&obstack
, "</library-list>\n");
2981 buf
= (const char *) obstack_finish (&obstack
);
2982 len_avail
= strlen (buf
);
2983 if (offset
>= len_avail
)
2987 if (len
> len_avail
- offset
)
2988 len
= len_avail
- offset
;
2989 memcpy (readbuf
, buf
+ offset
, len
);
2992 obstack_free (&obstack
, NULL
);
2993 *xfered_len
= (ULONGEST
) len
;
2994 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2997 enum target_xfer_status
2998 windows_nat_target::xfer_partial (enum target_object object
,
2999 const char *annex
, gdb_byte
*readbuf
,
3000 const gdb_byte
*writebuf
, ULONGEST offset
,
3001 ULONGEST len
, ULONGEST
*xfered_len
)
3005 case TARGET_OBJECT_MEMORY
:
3006 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
3008 case TARGET_OBJECT_LIBRARIES
:
3009 return windows_xfer_shared_libraries (this, object
, annex
, readbuf
,
3010 writebuf
, offset
, len
, xfered_len
);
3013 if (beneath () == NULL
)
3015 /* This can happen when requesting the transfer of unsupported
3016 objects before a program has been started (and therefore
3017 with the current_target having no target beneath). */
3018 return TARGET_XFER_E_IO
;
3020 return beneath ()->xfer_partial (object
, annex
,
3021 readbuf
, writebuf
, offset
, len
,
3026 /* Provide thread local base, i.e. Thread Information Block address.
3027 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3030 windows_nat_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
3032 windows_thread_info
*th
;
3034 th
= thread_rec (ptid
.tid (), 0);
3039 *addr
= th
->thread_local_base
;
3045 windows_nat_target::get_ada_task_ptid (long lwp
, long thread
)
3047 return ptid_t (inferior_ptid
.pid (), 0, lwp
);
3050 /* Implementation of the to_thread_name method. */
3053 windows_nat_target::thread_name (struct thread_info
*thr
)
3055 return thread_rec (thr
->ptid
.tid (), 0)->name
;
3060 _initialize_windows_nat (void)
3062 x86_dr_low
.set_control
= cygwin_set_dr7
;
3063 x86_dr_low
.set_addr
= cygwin_set_dr
;
3064 x86_dr_low
.get_addr
= cygwin_get_dr
;
3065 x86_dr_low
.get_status
= cygwin_get_dr6
;
3066 x86_dr_low
.get_control
= cygwin_get_dr7
;
3068 /* x86_dr_low.debug_register_length field is set by
3069 calling x86_set_debug_register_length function
3070 in processor windows specific native file. */
3072 add_inf_child_target (&the_windows_nat_target
);
3075 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
3078 add_com ("signal-event", class_run
, signal_event_command
, _("\
3079 Signal a crashed process with event ID, to allow its debugging.\n\
3080 This command is needed in support of setting up GDB as JIT debugger on \
3081 MS-Windows. The command should be invoked from the GDB command line using \
3082 the '-ex' command-line option. The ID of the event that blocks the \
3083 crashed process will be supplied by the Windows JIT debugging mechanism."));
3086 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
3087 Set use of shell to start subprocess."), _("\
3088 Show use of shell to start subprocess."), NULL
,
3090 NULL
, /* FIXME: i18n: */
3091 &setlist
, &showlist
);
3093 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
3094 &cygwin_exceptions
, _("\
3095 Break when an exception is detected in the Cygwin DLL itself."), _("\
3096 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
3098 NULL
, /* FIXME: i18n: */
3099 &setlist
, &showlist
);
3102 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
3103 Set creation of new console when creating child process."), _("\
3104 Show creation of new console when creating child process."), NULL
,
3106 NULL
, /* FIXME: i18n: */
3107 &setlist
, &showlist
);
3109 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
3110 Set creation of new group when creating child process."), _("\
3111 Show creation of new group when creating child process."), NULL
,
3113 NULL
, /* FIXME: i18n: */
3114 &setlist
, &showlist
);
3116 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
3117 Set whether to display execution in child process."), _("\
3118 Show whether to display execution in child process."), NULL
,
3120 NULL
, /* FIXME: i18n: */
3121 &setlist
, &showlist
);
3123 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
3124 Set whether to display kernel events in child process."), _("\
3125 Show whether to display kernel events in child process."), NULL
,
3127 NULL
, /* FIXME: i18n: */
3128 &setlist
, &showlist
);
3130 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
3131 Set whether to display memory accesses in child process."), _("\
3132 Show whether to display memory accesses in child process."), NULL
,
3134 NULL
, /* FIXME: i18n: */
3135 &setlist
, &showlist
);
3137 add_setshow_boolean_cmd ("debugexceptions", class_support
,
3138 &debug_exceptions
, _("\
3139 Set whether to display kernel exceptions in child process."), _("\
3140 Show whether to display kernel exceptions in child process."), NULL
,
3142 NULL
, /* FIXME: i18n: */
3143 &setlist
, &showlist
);
3145 init_w32_command_list ();
3147 add_cmd ("selector", class_info
, display_selectors
,
3148 _("Display selectors infos."),
3152 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3154 /* Pass the address ADDR to the inferior in the I'th debug register.
3155 Here we just store the address in dr array, the registers will be
3156 actually set up when windows_continue is called. */
3158 cygwin_set_dr (int i
, CORE_ADDR addr
)
3161 internal_error (__FILE__
, __LINE__
,
3162 _("Invalid register %d in cygwin_set_dr.\n"), i
);
3164 debug_registers_changed
= 1;
3165 debug_registers_used
= 1;
3168 /* Pass the value VAL to the inferior in the DR7 debug control
3169 register. Here we just store the address in D_REGS, the watchpoint
3170 will be actually set up in windows_wait. */
3172 cygwin_set_dr7 (unsigned long val
)
3174 dr
[7] = (CORE_ADDR
) val
;
3175 debug_registers_changed
= 1;
3176 debug_registers_used
= 1;
3179 /* Get the value of debug register I from the inferior. */
3182 cygwin_get_dr (int i
)
3187 /* Get the value of the DR6 debug status register from the inferior.
3188 Here we just return the value stored in dr[6]
3189 by the last call to thread_rec for current_event.dwThreadId id. */
3190 static unsigned long
3191 cygwin_get_dr6 (void)
3193 return (unsigned long) dr
[6];
3196 /* Get the value of the DR7 debug status register from the inferior.
3197 Here we just return the value stored in dr[7] by the last call to
3198 thread_rec for current_event.dwThreadId id. */
3200 static unsigned long
3201 cygwin_get_dr7 (void)
3203 return (unsigned long) dr
[7];
3206 /* Determine if the thread referenced by "ptid" is alive
3207 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3208 it means that the thread has died. Otherwise it is assumed to be alive. */
3211 windows_nat_target::thread_alive (ptid_t ptid
)
3215 gdb_assert (ptid
.tid () != 0);
3218 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) != WAIT_OBJECT_0
;
3222 _initialize_check_for_gdb_ini (void)
3225 if (inhibit_gdbinit
)
3228 homedir
= getenv ("HOME");
3232 char *oldini
= (char *) alloca (strlen (homedir
) +
3233 sizeof ("gdb.ini") + 1);
3234 strcpy (oldini
, homedir
);
3235 p
= strchr (oldini
, '\0');
3236 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
3238 strcpy (p
, "gdb.ini");
3239 if (access (oldini
, 0) == 0)
3241 int len
= strlen (oldini
);
3242 char *newini
= (char *) alloca (len
+ 2);
3244 xsnprintf (newini
, len
+ 2, "%.*s.gdbinit",
3245 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
3246 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
3251 /* Define dummy functions which always return error for the rare cases where
3252 these functions could not be found. */
3254 bad_DebugActiveProcessStop (DWORD w
)
3259 bad_DebugBreakProcess (HANDLE w
)
3264 bad_DebugSetProcessKillOnExit (BOOL w
)
3269 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
3276 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
3282 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
3289 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
3295 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
3301 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
3307 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
3315 /* Load any functions which may not be available in ancient versions
3319 _initialize_loadable (void)
3323 #define GPA(m, func) \
3324 func = (func ## _ftype *) GetProcAddress (m, #func)
3326 hm
= LoadLibrary ("kernel32.dll");
3329 GPA (hm
, DebugActiveProcessStop
);
3330 GPA (hm
, DebugBreakProcess
);
3331 GPA (hm
, DebugSetProcessKillOnExit
);
3332 GPA (hm
, GetConsoleFontSize
);
3333 GPA (hm
, DebugActiveProcessStop
);
3334 GPA (hm
, GetCurrentConsoleFont
);
3337 /* Set variables to dummy versions of these processes if the function
3338 wasn't found in kernel32.dll. */
3339 if (!DebugBreakProcess
)
3340 DebugBreakProcess
= bad_DebugBreakProcess
;
3341 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
3343 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
3344 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
3346 if (!GetConsoleFontSize
)
3347 GetConsoleFontSize
= bad_GetConsoleFontSize
;
3348 if (!GetCurrentConsoleFont
)
3349 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
3351 /* Load optional functions used for retrieving filename information
3352 associated with the currently debugged process or its dlls. */
3353 hm
= LoadLibrary ("psapi.dll");
3356 GPA (hm
, EnumProcessModules
);
3357 GPA (hm
, GetModuleInformation
);
3358 GetModuleFileNameEx
= (GetModuleFileNameEx_ftype
*)
3359 GetProcAddress (hm
, GetModuleFileNameEx_name
);
3362 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
3364 /* Set variables to dummy versions of these processes if the function
3365 wasn't found in psapi.dll. */
3366 EnumProcessModules
= bad_EnumProcessModules
;
3367 GetModuleInformation
= bad_GetModuleInformation
;
3368 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
3369 /* This will probably fail on Windows 9x/Me. Let the user know
3370 that we're missing some functionality. */
3372 cannot automatically find executable file or library to read symbols.\n\
3373 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3376 hm
= LoadLibrary ("advapi32.dll");
3379 GPA (hm
, OpenProcessToken
);
3380 GPA (hm
, LookupPrivilegeValueA
);
3381 GPA (hm
, AdjustTokenPrivileges
);
3382 /* Only need to set one of these since if OpenProcessToken fails nothing
3384 if (!OpenProcessToken
|| !LookupPrivilegeValueA
3385 || !AdjustTokenPrivileges
)
3386 OpenProcessToken
= bad_OpenProcessToken
;