1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2014 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 */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #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"
70 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
71 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
72 #define DebugBreakProcess dyn_DebugBreakProcess
73 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleInformation dyn_GetModuleInformation
76 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77 #define OpenProcessToken dyn_OpenProcessToken
78 #define GetConsoleFontSize dyn_GetConsoleFontSize
79 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
81 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
82 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
83 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
84 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
85 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
86 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
88 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
90 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
91 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
92 static BOOL
WINAPI (*GetCurrentConsoleFont
) (HANDLE
, BOOL
,
94 static COORD
WINAPI (*GetConsoleFontSize
) (HANDLE
, DWORD
);
98 #undef GetModuleFileNameEx
101 # define __PMAX (MAX_PATH + 1)
102 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
103 # define STARTUPINFO STARTUPINFOA
104 # define CreateProcess CreateProcessA
105 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
106 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
108 # define __PMAX PATH_MAX
109 /* The starting and ending address of the cygwin1.dll text segment. */
110 static CORE_ADDR cygwin_load_start
;
111 static CORE_ADDR cygwin_load_end
;
113 typedef wchar_t cygwin_buf_t
;
114 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
,
116 # define STARTUPINFO STARTUPINFOW
117 # define CreateProcess CreateProcessW
118 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
119 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
122 static int have_saved_context
; /* True if we've saved context from a
124 static CONTEXT saved_context
; /* Containes the saved context from a
127 /* If we're not using the old Cygwin header file set, define the
128 following which never should have been in the generic Win32 API
129 headers in the first place since they were our own invention... */
130 #ifndef _GNU_H_WINDOWS_H
133 FLAG_TRACE_BIT
= 0x100,
134 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
138 #ifndef CONTEXT_EXTENDED_REGISTERS
139 /* This macro is only defined on ia32. It only makes sense on this target,
140 so define it as zero if not already defined. */
141 #define CONTEXT_EXTENDED_REGISTERS 0
144 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
145 | CONTEXT_EXTENDED_REGISTERS
147 static uintptr_t dr
[8];
148 static int debug_registers_changed
;
149 static int debug_registers_used
;
151 static int windows_initialization_done
;
152 #define DR6_CLEAR_VALUE 0xffff0ff0
154 /* The string sent by cygwin when it processes a signal.
155 FIXME: This should be in a cygwin include file. */
156 #ifndef _CYGWIN_SIGNAL_STRING
157 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
160 #define CHECK(x) check (x, __FILE__,__LINE__)
161 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
162 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
163 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
164 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
166 static void windows_stop (struct target_ops
*self
, ptid_t
);
167 static int windows_thread_alive (struct target_ops
*, ptid_t
);
168 static void windows_kill_inferior (struct target_ops
*);
170 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
171 static void cygwin_set_dr7 (unsigned long val
);
172 static CORE_ADDR
cygwin_get_dr (int i
);
173 static unsigned long cygwin_get_dr6 (void);
174 static unsigned long cygwin_get_dr7 (void);
176 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
177 /* Set if a signal was received from the debugged process. */
179 /* Thread information structure used to track information that is
180 not available in gdb's thread structure. */
181 typedef struct thread_info_struct
183 struct thread_info_struct
*next
;
186 CORE_ADDR thread_local_base
;
195 static thread_info thread_head
;
197 /* The process and thread handles for the above context. */
199 static DEBUG_EVENT current_event
; /* The current debug event from
201 static HANDLE current_process_handle
; /* Currently executing process */
202 static thread_info
*current_thread
; /* Info on currently selected thread */
203 static DWORD main_thread_id
; /* Thread ID of the main thread */
205 /* Counts of things. */
206 static int exception_count
= 0;
207 static int event_count
= 0;
208 static int saw_create
;
209 static int open_process_used
= 0;
212 static int new_console
= 0;
214 static int cygwin_exceptions
= 0;
216 static int new_group
= 1;
217 static int debug_exec
= 0; /* show execution */
218 static int debug_events
= 0; /* show events from kernel */
219 static int debug_memory
= 0; /* show target memory accesses */
220 static int debug_exceptions
= 0; /* show target exceptions */
221 static int useshell
= 0; /* use shell for subprocesses */
223 /* This vector maps GDB's idea of a register's number into an offset
224 in the windows exception context vector.
226 It also contains the bit mask needed to load the register in question.
228 The contents of this table can only be computed by the units
229 that provide CPU-specific support for Windows native debugging.
230 These units should set the table by calling
231 windows_set_context_register_offsets.
233 One day we could read a reg, we could inspect the context we
234 already have loaded, if it doesn't have the bit set that we need,
235 we read that set of registers in using GetThreadContext. If the
236 context already contains what we need, we just unpack it. Then to
237 write a register, first we have to ensure that the context contains
238 the other regs of the group, and then we copy the info in and set
241 static const int *mappings
;
243 /* The function to use in order to determine whether a register is
244 a segment register or not. */
245 static segment_register_p_ftype
*segment_register_p
;
247 /* This vector maps the target's idea of an exception (extracted
248 from the DEBUG_EVENT structure) to GDB's idea. */
250 struct xlate_exception
256 static const struct xlate_exception
259 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
260 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
261 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
262 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
263 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
264 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
267 /* Set the MAPPINGS static global to OFFSETS.
268 See the description of MAPPINGS for more details. */
271 windows_set_context_register_offsets (const int *offsets
)
276 /* See windows-nat.h. */
279 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
281 segment_register_p
= fun
;
285 check (BOOL ok
, const char *file
, int line
)
288 printf_filtered ("error return %s:%d was %u\n", file
, line
,
289 (unsigned) GetLastError ());
292 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
293 then also retrieve the context for this thread. If GET_CONTEXT is
294 negative, then don't suspend the thread. */
296 thread_rec (DWORD id
, int get_context
)
300 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
303 if (!th
->suspended
&& get_context
)
305 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
307 if (SuspendThread (th
->h
) == (DWORD
) -1)
309 DWORD err
= GetLastError ();
311 /* We get Access Denied (5) when trying to suspend
312 threads that Windows started on behalf of the
313 debuggee, usually when those threads are just
315 if (err
!= ERROR_ACCESS_DENIED
)
316 warning (_("SuspendThread (tid=0x%x) failed."
318 (unsigned) id
, (unsigned) err
);
324 else if (get_context
< 0)
326 th
->reload_context
= 1;
334 /* Add a thread to the thread list. */
336 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
341 gdb_assert (ptid_get_tid (ptid
) != 0);
343 id
= ptid_get_tid (ptid
);
345 if ((th
= thread_rec (id
, FALSE
)))
348 th
= XCNEW (thread_info
);
351 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
352 th
->next
= thread_head
.next
;
353 thread_head
.next
= th
;
355 /* Set the debug registers for the new thread if they are used. */
356 if (debug_registers_used
)
358 /* Only change the value of the debug registers. */
359 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
360 CHECK (GetThreadContext (th
->h
, &th
->context
));
361 th
->context
.Dr0
= dr
[0];
362 th
->context
.Dr1
= dr
[1];
363 th
->context
.Dr2
= dr
[2];
364 th
->context
.Dr3
= dr
[3];
365 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
366 th
->context
.Dr7
= dr
[7];
367 CHECK (SetThreadContext (th
->h
, &th
->context
));
368 th
->context
.ContextFlags
= 0;
373 /* Clear out any old thread list and reintialize it to a
376 windows_init_thread_list (void)
378 thread_info
*th
= &thread_head
;
380 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
382 while (th
->next
!= NULL
)
384 thread_info
*here
= th
->next
;
385 th
->next
= here
->next
;
388 thread_head
.next
= NULL
;
391 /* Delete a thread from the list of threads. */
393 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
398 gdb_assert (ptid_get_tid (ptid
) != 0);
400 id
= ptid_get_tid (ptid
);
403 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
404 else if (print_thread_events
&& id
!= main_thread_id
)
405 printf_unfiltered (_("[%s exited with code %u]\n"),
406 target_pid_to_str (ptid
), (unsigned) exit_code
);
407 delete_thread (ptid
);
409 for (th
= &thread_head
;
410 th
->next
!= NULL
&& th
->next
->id
!= id
;
414 if (th
->next
!= NULL
)
416 thread_info
*here
= th
->next
;
417 th
->next
= here
->next
;
423 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
425 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
426 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
427 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
431 return; /* Windows sometimes uses a non-existent thread id in its
434 if (current_thread
->reload_context
)
436 #ifdef __COPY_CONTEXT_SIZE
437 if (have_saved_context
)
439 /* Lie about where the program actually is stopped since
440 cygwin has informed us that we should consider the signal
441 to have occurred at another location which is stored in
443 memcpy (¤t_thread
->context
, &saved_context
,
444 __COPY_CONTEXT_SIZE
);
445 have_saved_context
= 0;
450 thread_info
*th
= current_thread
;
451 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
452 CHECK (GetThreadContext (th
->h
, &th
->context
));
453 /* Copy dr values from that thread.
454 But only if there were not modified since last stop.
456 if (!debug_registers_changed
)
458 dr
[0] = th
->context
.Dr0
;
459 dr
[1] = th
->context
.Dr1
;
460 dr
[2] = th
->context
.Dr2
;
461 dr
[3] = th
->context
.Dr3
;
462 dr
[6] = th
->context
.Dr6
;
463 dr
[7] = th
->context
.Dr7
;
466 current_thread
->reload_context
= 0;
469 if (r
== I387_FISEG_REGNUM (tdep
))
471 l
= *((long *) context_offset
) & 0xffff;
472 regcache_raw_supply (regcache
, r
, (char *) &l
);
474 else if (r
== I387_FOP_REGNUM (tdep
))
476 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
477 regcache_raw_supply (regcache
, r
, (char *) &l
);
479 else if (segment_register_p (r
))
481 /* GDB treats segment registers as 32bit registers, but they are
482 in fact only 16 bits long. Make sure we do not read extra
483 bits from our source buffer. */
484 l
= *((long *) context_offset
) & 0xffff;
485 regcache_raw_supply (regcache
, r
, (char *) &l
);
488 regcache_raw_supply (regcache
, r
, context_offset
);
491 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
492 do_windows_fetch_inferior_registers (regcache
, r
);
497 windows_fetch_inferior_registers (struct target_ops
*ops
,
498 struct regcache
*regcache
, int r
)
500 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
501 /* Check if current_thread exists. Windows sometimes uses a non-existent
502 thread id in its events. */
504 do_windows_fetch_inferior_registers (regcache
, r
);
508 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
511 /* Windows sometimes uses a non-existent thread id in its events. */;
513 regcache_raw_collect (regcache
, r
,
514 ((char *) ¤t_thread
->context
) + mappings
[r
]);
517 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
518 do_windows_store_inferior_registers (regcache
, r
);
522 /* Store a new register value into the current thread context. */
524 windows_store_inferior_registers (struct target_ops
*ops
,
525 struct regcache
*regcache
, int r
)
527 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
528 /* Check if current_thread exists. Windows sometimes uses a non-existent
529 thread id in its events. */
531 do_windows_store_inferior_registers (regcache
, r
);
534 /* Encapsulate the information required in a call to
535 symbol_file_add_args. */
536 struct safe_symbol_file_add_args
540 struct section_addr_info
*addrs
;
543 struct ui_file
*err
, *out
;
547 /* Maintain a linked list of "so" information. */
553 static struct so_list solib_start
, *solib_end
;
555 /* Call symbol_file_add with stderr redirected. We don't care if there
558 safe_symbol_file_add_stub (void *argv
)
560 #define p ((struct safe_symbol_file_add_args *) argv)
561 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
562 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
563 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
568 /* Restore gdb's stderr after calling symbol_file_add. */
570 safe_symbol_file_add_cleanup (void *p
)
572 #define sp ((struct safe_symbol_file_add_args *)p)
573 gdb_flush (gdb_stderr
);
574 gdb_flush (gdb_stdout
);
575 ui_file_delete (gdb_stderr
);
576 ui_file_delete (gdb_stdout
);
577 gdb_stderr
= sp
->err
;
578 gdb_stdout
= sp
->out
;
582 /* symbol_file_add wrapper that prevents errors from being displayed. */
583 static struct objfile
*
584 safe_symbol_file_add (char *name
, int from_tty
,
585 struct section_addr_info
*addrs
,
586 int mainline
, int flags
)
588 struct safe_symbol_file_add_args p
;
589 struct cleanup
*cleanup
;
591 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
595 gdb_flush (gdb_stderr
);
596 gdb_flush (gdb_stdout
);
597 gdb_stderr
= ui_file_new ();
598 gdb_stdout
= ui_file_new ();
600 p
.from_tty
= from_tty
;
602 p
.mainline
= mainline
;
604 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
606 do_cleanups (cleanup
);
610 static struct so_list
*
611 windows_make_so (const char *name
, LPVOID load_addr
)
618 WIN32_FIND_DATA w32_fd
;
619 HANDLE h
= FindFirstFile(name
, &w32_fd
);
621 if (h
== INVALID_HANDLE_VALUE
)
627 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
629 p
= strrchr (buf
, '\\');
632 SetCurrentDirectory (buf
);
633 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
634 SetCurrentDirectory (cwd
);
637 if (strcasecmp (buf
, "ntdll.dll") == 0)
639 GetSystemDirectory (buf
, sizeof (buf
));
640 strcat (buf
, "\\ntdll.dll");
643 cygwin_buf_t buf
[__PMAX
];
646 if (access (name
, F_OK
) != 0)
648 if (strcasecmp (name
, "ntdll.dll") == 0)
651 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
652 wcscat (buf
, L
"\\ntdll.dll");
656 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
657 strcat (buf
, "\\ntdll.dll");
662 so
= XCNEW (struct so_list
);
663 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
664 so
->lm_info
->load_addr
= load_addr
;
665 strcpy (so
->so_original_name
, name
);
667 strcpy (so
->so_name
, buf
);
670 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
671 SO_NAME_MAX_PATH_SIZE
);
674 char *rname
= realpath (name
, NULL
);
675 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
677 strcpy (so
->so_name
, rname
);
681 error (_("dll path too long"));
683 /* Record cygwin1.dll .text start/end. */
684 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
685 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
688 asection
*text
= NULL
;
691 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
696 if (bfd_check_format (abfd
, bfd_object
))
697 text
= bfd_get_section_by_name (abfd
, ".text");
701 gdb_bfd_unref (abfd
);
705 /* The symbols in a dll are offset by 0x1000, which is the
706 offset from 0 of the first byte in an image - because of the
707 file header and the section alignment. */
708 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
710 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
712 gdb_bfd_unref (abfd
);
720 get_image_name (HANDLE h
, void *address
, int unicode
)
723 static char buf
[__PMAX
];
725 static char buf
[(2 * __PMAX
) + 1];
727 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
733 /* Attempt to read the name of the dll that was detected.
734 This is documented to work only when actively debugging
735 a program. It will not work for attached processes. */
739 /* See if we could read the address of a string, and that the
740 address isn't null. */
741 if (!ReadProcessMemory (h
, address
, &address_ptr
,
742 sizeof (address_ptr
), &done
)
743 || done
!= sizeof (address_ptr
) || !address_ptr
)
746 /* Find the length of the string. */
747 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
748 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
752 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
755 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
756 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
759 wcstombs (buf
, unicode_address
, __PMAX
);
761 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
769 /* Handle a DLL load event, and return 1.
771 This function assumes that this event did not occur during inferior
772 initialization, where their event info may be incomplete (see
773 do_initial_windows_stuff and windows_add_all_dlls for more info
774 on how we handle DLL loading during that phase). */
777 handle_load_dll (void *dummy
)
779 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
782 /* Try getting the DLL name via the lpImageName field of the event.
783 Note that Microsoft documents this fields as strictly optional,
784 in the sense that it might be NULL. And the first DLL event in
785 particular is explicitly documented as "likely not pass[ed]"
786 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
787 dll_name
= get_image_name (current_process_handle
,
788 event
->lpImageName
, event
->fUnicode
);
792 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
793 solib_end
= solib_end
->next
;
795 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
796 host_address_to_string (solib_end
->lm_info
->load_addr
)));
802 windows_free_so (struct so_list
*so
)
809 /* Handle a DLL unload event.
810 Return 1 if successful, or zero otherwise.
812 This function assumes that this event did not occur during inferior
813 initialization, where their event info may be incomplete (see
814 do_initial_windows_stuff and windows_add_all_dlls for more info
815 on how we handle DLL loading during that phase). */
818 handle_unload_dll (void *dummy
)
820 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
823 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
824 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
826 struct so_list
*sodel
= so
->next
;
828 so
->next
= sodel
->next
;
831 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
833 windows_free_so (sodel
);
837 /* We did not find any DLL that was previously loaded at this address,
838 so register a complaint. We do not report an error, because we have
839 observed that this may be happening under some circumstances. For
840 instance, running 32bit applications on x64 Windows causes us to receive
841 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
842 events are apparently caused by the WOW layer, the interface between
843 32bit and 64bit worlds). */
844 complaint (&symfile_complaints
, _("dll starting at %s not found."),
845 host_address_to_string (lpBaseOfDll
));
850 /* Clear list of loaded DLLs. */
852 windows_clear_solib (void)
854 solib_start
.next
= NULL
;
855 solib_end
= &solib_start
;
858 /* Load DLL symbol info. */
860 dll_symbol_command (char *args
, int from_tty
)
866 error (_("dll-symbols requires a file name"));
869 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
871 char *newargs
= (char *) alloca (n
+ 4 + 1);
872 strcpy (newargs
, args
);
873 strcat (newargs
, ".dll");
877 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
880 /* Handle DEBUG_STRING output from child process.
881 Cygwin prepends its messages with a "cygwin:". Interpret this as
882 a Cygwin signal. Otherwise just print the string as a warning. */
884 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
889 if (!target_read_string
890 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
894 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
895 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
898 if (strncmp (s
, "cYg", 3) != 0)
902 #ifdef __COPY_CONTEXT_SIZE
905 /* Got a cygwin signal marker. A cygwin signal is followed by
906 the signal number itself and then optionally followed by the
907 thread id and address to saved context within the DLL. If
908 these are supplied, then the given thread is assumed to have
909 issued the signal and the context from the thread is assumed
910 to be stored at the given address in the inferior. Tell gdb
911 to treat this like a real signal. */
913 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
914 int gotasig
= gdb_signal_from_host (sig
);
916 ourstatus
->value
.sig
= gotasig
;
922 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
923 retval
= strtoul (p
, &p
, 0);
925 retval
= main_thread_id
;
926 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
927 && ReadProcessMemory (current_process_handle
, x
,
929 __COPY_CONTEXT_SIZE
, &n
)
930 && n
== __COPY_CONTEXT_SIZE
)
931 have_saved_context
= 1;
932 current_event
.dwThreadId
= retval
;
943 display_selector (HANDLE thread
, DWORD sel
)
946 if (GetThreadSelectorEntry (thread
, sel
, &info
))
949 printf_filtered ("0x%03x: ", (unsigned) sel
);
950 if (!info
.HighWord
.Bits
.Pres
)
952 puts_filtered ("Segment not present\n");
955 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
956 (info
.HighWord
.Bits
.BaseMid
<< 16)
958 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
959 if (info
.HighWord
.Bits
.Granularity
)
960 limit
= (limit
<< 12) | 0xfff;
961 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
962 if (info
.HighWord
.Bits
.Default_Big
)
963 puts_filtered(" 32-bit ");
965 puts_filtered(" 16-bit ");
966 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
969 puts_filtered ("Data (Read-Only, Exp-up");
972 puts_filtered ("Data (Read/Write, Exp-up");
975 puts_filtered ("Unused segment (");
978 puts_filtered ("Data (Read/Write, Exp-down");
981 puts_filtered ("Code (Exec-Only, N.Conf");
984 puts_filtered ("Code (Exec/Read, N.Conf");
987 puts_filtered ("Code (Exec-Only, Conf");
990 puts_filtered ("Code (Exec/Read, Conf");
993 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
995 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
996 puts_filtered(", N.Acc");
997 puts_filtered (")\n");
998 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
999 puts_filtered("System selector ");
1000 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1001 if (info
.HighWord
.Bits
.Granularity
)
1002 puts_filtered ("Page granular.\n");
1004 puts_filtered ("Byte granular.\n");
1009 DWORD err
= GetLastError ();
1010 if (err
== ERROR_NOT_SUPPORTED
)
1011 printf_filtered ("Function not supported\n");
1013 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1019 display_selectors (char * args
, int from_tty
)
1021 if (!current_thread
)
1023 puts_filtered ("Impossible to display selectors now.\n");
1029 puts_filtered ("Selector $cs\n");
1030 display_selector (current_thread
->h
,
1031 current_thread
->context
.SegCs
);
1032 puts_filtered ("Selector $ds\n");
1033 display_selector (current_thread
->h
,
1034 current_thread
->context
.SegDs
);
1035 puts_filtered ("Selector $es\n");
1036 display_selector (current_thread
->h
,
1037 current_thread
->context
.SegEs
);
1038 puts_filtered ("Selector $ss\n");
1039 display_selector (current_thread
->h
,
1040 current_thread
->context
.SegSs
);
1041 puts_filtered ("Selector $fs\n");
1042 display_selector (current_thread
->h
,
1043 current_thread
->context
.SegFs
);
1044 puts_filtered ("Selector $gs\n");
1045 display_selector (current_thread
->h
,
1046 current_thread
->context
.SegGs
);
1051 sel
= parse_and_eval_long (args
);
1052 printf_filtered ("Selector \"%s\"\n",args
);
1053 display_selector (current_thread
->h
, sel
);
1057 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1058 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1059 host_address_to_string (\
1060 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1063 handle_exception (struct target_waitstatus
*ourstatus
)
1066 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1068 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1070 /* Record the context of the current thread. */
1071 th
= thread_rec (current_event
.dwThreadId
, -1);
1075 case EXCEPTION_ACCESS_VIOLATION
:
1076 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1077 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1080 /* See if the access violation happened within the cygwin DLL
1081 itself. Cygwin uses a kind of exception handling to deal
1082 with passed-in invalid addresses. gdb should not treat
1083 these as real SEGVs since they will be silently handled by
1084 cygwin. A real SEGV will (theoretically) be caught by
1085 cygwin later in the process and will be sent as a
1086 cygwin-specific-signal. So, ignore SEGVs if they show up
1087 within the text segment of the DLL itself. */
1089 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1090 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1092 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1093 && addr
< cygwin_load_end
))
1094 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1095 && strncmp (fn
, "KERNEL32!IsBad",
1096 strlen ("KERNEL32!IsBad")) == 0))
1101 case STATUS_STACK_OVERFLOW
:
1102 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1103 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1105 case STATUS_FLOAT_DENORMAL_OPERAND
:
1106 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1107 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1109 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1110 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1111 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1113 case STATUS_FLOAT_INEXACT_RESULT
:
1114 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1115 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1117 case STATUS_FLOAT_INVALID_OPERATION
:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1119 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1121 case STATUS_FLOAT_OVERFLOW
:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1123 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1125 case STATUS_FLOAT_STACK_CHECK
:
1126 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1127 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1129 case STATUS_FLOAT_UNDERFLOW
:
1130 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1131 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1133 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1134 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1135 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1137 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1138 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1139 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1141 case STATUS_INTEGER_OVERFLOW
:
1142 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1143 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1145 case EXCEPTION_BREAKPOINT
:
1146 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1147 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1150 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1151 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1153 case DBG_CONTROL_BREAK
:
1154 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1155 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1157 case EXCEPTION_SINGLE_STEP
:
1158 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1159 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1161 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1162 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1163 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1165 case EXCEPTION_PRIV_INSTRUCTION
:
1166 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1167 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1169 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1170 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1171 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1174 /* Treat unhandled first chance exceptions specially. */
1175 if (current_event
.u
.Exception
.dwFirstChance
)
1177 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1178 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1179 host_address_to_string (
1180 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1181 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1185 last_sig
= ourstatus
->value
.sig
;
1189 /* Resume thread specified by ID, or all artificially suspended
1190 threads, if we are continuing execution. KILLED non-zero means we
1191 have killed the inferior, so we should ignore weird errors due to
1192 threads shutting down. */
1194 windows_continue (DWORD continue_status
, int id
, int killed
)
1200 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1201 (unsigned) current_event
.dwProcessId
,
1202 (unsigned) current_event
.dwThreadId
,
1203 continue_status
== DBG_CONTINUE
?
1204 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1206 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1207 if ((id
== -1 || id
== (int) th
->id
)
1210 if (debug_registers_changed
)
1212 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1213 th
->context
.Dr0
= dr
[0];
1214 th
->context
.Dr1
= dr
[1];
1215 th
->context
.Dr2
= dr
[2];
1216 th
->context
.Dr3
= dr
[3];
1217 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1218 th
->context
.Dr7
= dr
[7];
1220 if (th
->context
.ContextFlags
)
1224 if (GetExitCodeThread (th
->h
, &ec
)
1225 && ec
== STILL_ACTIVE
)
1227 BOOL status
= SetThreadContext (th
->h
, &th
->context
);
1232 th
->context
.ContextFlags
= 0;
1234 if (th
->suspended
> 0)
1235 (void) ResumeThread (th
->h
);
1239 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1240 current_event
.dwThreadId
,
1243 debug_registers_changed
= 0;
1247 /* Called in pathological case where Windows fails to send a
1248 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1250 fake_create_process (void)
1252 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1253 current_event
.dwProcessId
);
1254 if (current_process_handle
!= NULL
)
1255 open_process_used
= 1;
1258 error (_("OpenProcess call failed, GetLastError = %u"),
1259 (unsigned) GetLastError ());
1260 /* We can not debug anything in that case. */
1262 main_thread_id
= current_event
.dwThreadId
;
1263 current_thread
= windows_add_thread (
1264 ptid_build (current_event
.dwProcessId
, 0,
1265 current_event
.dwThreadId
),
1266 current_event
.u
.CreateThread
.hThread
,
1267 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1268 return main_thread_id
;
1272 windows_resume (struct target_ops
*ops
,
1273 ptid_t ptid
, int step
, enum gdb_signal sig
)
1276 DWORD continue_status
= DBG_CONTINUE
;
1278 /* A specific PTID means `step only this thread id'. */
1279 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1281 /* If we're continuing all threads, it's the current inferior that
1282 should be handled specially. */
1284 ptid
= inferior_ptid
;
1286 if (sig
!= GDB_SIGNAL_0
)
1288 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1290 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1292 else if (sig
== last_sig
)
1293 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1296 /* This code does not seem to work, because
1297 the kernel does probably not consider changes in the ExceptionRecord
1298 structure when passing the exception to the inferior.
1299 Note that this seems possible in the exception handler itself. */
1302 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1303 if (xlate
[i
].us
== sig
)
1305 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1307 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1310 if (continue_status
== DBG_CONTINUE
)
1312 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1316 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1320 last_sig
= GDB_SIGNAL_0
;
1322 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1323 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1325 /* Get context for currently selected thread. */
1326 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1331 /* Single step by setting t bit. */
1332 struct regcache
*regcache
= get_current_regcache ();
1333 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1334 windows_fetch_inferior_registers (ops
, regcache
,
1335 gdbarch_ps_regnum (gdbarch
));
1336 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1339 if (th
->context
.ContextFlags
)
1341 if (debug_registers_changed
)
1343 th
->context
.Dr0
= dr
[0];
1344 th
->context
.Dr1
= dr
[1];
1345 th
->context
.Dr2
= dr
[2];
1346 th
->context
.Dr3
= dr
[3];
1347 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1348 th
->context
.Dr7
= dr
[7];
1350 CHECK (SetThreadContext (th
->h
, &th
->context
));
1351 th
->context
.ContextFlags
= 0;
1355 /* Allow continuing with the same signal that interrupted us.
1356 Otherwise complain. */
1359 windows_continue (continue_status
, -1, 0);
1361 windows_continue (continue_status
, ptid_get_tid (ptid
), 0);
1364 /* Ctrl-C handler used when the inferior is not run in the same console. The
1365 handler is in charge of interrupting the inferior using DebugBreakProcess.
1366 Note that this function is not available prior to Windows XP. In this case
1367 we emit a warning. */
1369 ctrl_c_handler (DWORD event_type
)
1371 const int attach_flag
= current_inferior ()->attach_flag
;
1373 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1374 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1377 /* If the inferior and the debugger share the same console, do nothing as
1378 the inferior has also received the Ctrl-C event. */
1379 if (!new_console
&& !attach_flag
)
1382 if (!DebugBreakProcess (current_process_handle
))
1383 warning (_("Could not interrupt program. "
1384 "Press Ctrl-c in the program console."));
1386 /* Return true to tell that Ctrl-C has been handled. */
1390 /* Get the next event from the child. Return 1 if the event requires
1391 handling by WFI (or whatever). */
1393 get_windows_debug_event (struct target_ops
*ops
,
1394 int pid
, struct target_waitstatus
*ourstatus
)
1397 DWORD continue_status
, event_code
;
1399 static thread_info dummy_thread_info
;
1402 last_sig
= GDB_SIGNAL_0
;
1404 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1408 continue_status
= DBG_CONTINUE
;
1410 event_code
= current_event
.dwDebugEventCode
;
1411 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1413 have_saved_context
= 0;
1417 case CREATE_THREAD_DEBUG_EVENT
:
1418 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1419 (unsigned) current_event
.dwProcessId
,
1420 (unsigned) current_event
.dwThreadId
,
1421 "CREATE_THREAD_DEBUG_EVENT"));
1422 if (saw_create
!= 1)
1424 struct inferior
*inf
;
1425 inf
= find_inferior_pid (current_event
.dwProcessId
);
1426 if (!saw_create
&& inf
->attach_flag
)
1428 /* Kludge around a Windows bug where first event is a create
1429 thread event. Caused when attached process does not have
1431 retval
= fake_create_process ();
1437 /* Record the existence of this thread. */
1438 retval
= current_event
.dwThreadId
;
1439 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1440 current_event
.dwThreadId
),
1441 current_event
.u
.CreateThread
.hThread
,
1442 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1446 case EXIT_THREAD_DEBUG_EVENT
:
1447 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1448 (unsigned) current_event
.dwProcessId
,
1449 (unsigned) current_event
.dwThreadId
,
1450 "EXIT_THREAD_DEBUG_EVENT"));
1452 if (current_event
.dwThreadId
!= main_thread_id
)
1454 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1455 current_event
.dwThreadId
),
1456 current_event
.u
.ExitThread
.dwExitCode
);
1457 th
= &dummy_thread_info
;
1461 case CREATE_PROCESS_DEBUG_EVENT
:
1462 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1463 (unsigned) current_event
.dwProcessId
,
1464 (unsigned) current_event
.dwThreadId
,
1465 "CREATE_PROCESS_DEBUG_EVENT"));
1466 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1467 if (++saw_create
!= 1)
1470 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1472 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1475 main_thread_id
= current_event
.dwThreadId
;
1476 /* Add the main thread. */
1477 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1478 current_event
.dwThreadId
),
1479 current_event
.u
.CreateProcessInfo
.hThread
,
1480 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1481 retval
= current_event
.dwThreadId
;
1484 case EXIT_PROCESS_DEBUG_EVENT
:
1485 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1486 (unsigned) current_event
.dwProcessId
,
1487 (unsigned) current_event
.dwThreadId
,
1488 "EXIT_PROCESS_DEBUG_EVENT"));
1489 if (!windows_initialization_done
)
1491 target_terminal_ours ();
1492 target_mourn_inferior ();
1493 error (_("During startup program exited with code 0x%x."),
1494 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1496 else if (saw_create
== 1)
1498 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1499 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1500 retval
= main_thread_id
;
1504 case LOAD_DLL_DEBUG_EVENT
:
1505 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1506 (unsigned) current_event
.dwProcessId
,
1507 (unsigned) current_event
.dwThreadId
,
1508 "LOAD_DLL_DEBUG_EVENT"));
1509 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1510 if (saw_create
!= 1 || ! windows_initialization_done
)
1512 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1513 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1514 ourstatus
->value
.integer
= 0;
1515 retval
= main_thread_id
;
1518 case UNLOAD_DLL_DEBUG_EVENT
:
1519 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1520 (unsigned) current_event
.dwProcessId
,
1521 (unsigned) current_event
.dwThreadId
,
1522 "UNLOAD_DLL_DEBUG_EVENT"));
1523 if (saw_create
!= 1 || ! windows_initialization_done
)
1525 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1526 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1527 ourstatus
->value
.integer
= 0;
1528 retval
= main_thread_id
;
1531 case EXCEPTION_DEBUG_EVENT
:
1532 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1533 (unsigned) current_event
.dwProcessId
,
1534 (unsigned) current_event
.dwThreadId
,
1535 "EXCEPTION_DEBUG_EVENT"));
1536 if (saw_create
!= 1)
1538 switch (handle_exception (ourstatus
))
1541 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1544 retval
= current_event
.dwThreadId
;
1548 continue_status
= -1;
1553 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1554 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1555 (unsigned) current_event
.dwProcessId
,
1556 (unsigned) current_event
.dwThreadId
,
1557 "OUTPUT_DEBUG_STRING_EVENT"));
1558 if (saw_create
!= 1)
1560 retval
= handle_output_debug_string (ourstatus
);
1564 if (saw_create
!= 1)
1566 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1567 (unsigned) current_event
.dwProcessId
,
1568 (unsigned) current_event
.dwThreadId
);
1569 printf_unfiltered (" unknown event code %u\n",
1570 (unsigned) current_event
.dwDebugEventCode
);
1574 if (!retval
|| saw_create
!= 1)
1576 if (continue_status
== -1)
1577 windows_resume (ops
, minus_one_ptid
, 0, 1);
1579 CHECK (windows_continue (continue_status
, -1, 0));
1583 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1585 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1592 /* Wait for interesting events to occur in the target process. */
1594 windows_wait (struct target_ops
*ops
,
1595 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1599 target_terminal_ours ();
1601 /* We loop when we get a non-standard exception rather than return
1602 with a SPURIOUS because resume can try and step or modify things,
1603 which needs a current_thread->h. But some of these exceptions mark
1604 the birth or death of threads, which mean that the current thread
1605 isn't necessarily what you think it is. */
1611 /* If the user presses Ctrl-c while the debugger is waiting
1612 for an event, he expects the debugger to interrupt his program
1613 and to get the prompt back. There are two possible situations:
1615 - The debugger and the program do not share the console, in
1616 which case the Ctrl-c event only reached the debugger.
1617 In that case, the ctrl_c handler will take care of interrupting
1618 the inferior. Note that this case is working starting with
1619 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1622 - The debugger and the program share the same console, in which
1623 case both debugger and inferior will receive the Ctrl-c event.
1624 In that case the ctrl_c handler will ignore the event, as the
1625 Ctrl-c event generated inside the inferior will trigger the
1626 expected debug event.
1628 FIXME: brobecker/2008-05-20: If the inferior receives the
1629 signal first and the delay until GDB receives that signal
1630 is sufficiently long, GDB can sometimes receive the SIGINT
1631 after we have unblocked the CTRL+C handler. This would
1632 lead to the debugger stopping prematurely while handling
1633 the new-thread event that comes with the handling of the SIGINT
1634 inside the inferior, and then stop again immediately when
1635 the user tries to resume the execution in the inferior.
1636 This is a classic race that we should try to fix one day. */
1637 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1638 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1639 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1642 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1647 if (deprecated_ui_loop_hook
!= NULL
)
1648 detach
= deprecated_ui_loop_hook (0);
1651 windows_kill_inferior (ops
);
1656 /* Iterate over all DLLs currently mapped by our inferior, and
1657 add them to our list of solibs. */
1660 windows_add_all_dlls (void)
1663 HMODULE dummy_hmodule
;
1668 if (EnumProcessModules (current_process_handle
, &dummy_hmodule
,
1669 sizeof (HMODULE
), &cb_needed
) == 0)
1675 hmodules
= (HMODULE
*) alloca (cb_needed
);
1676 if (EnumProcessModules (current_process_handle
, hmodules
,
1677 cb_needed
, &cb_needed
) == 0)
1680 for (i
= 1; i
< (int) (cb_needed
/ sizeof (HMODULE
)); i
++)
1684 wchar_t dll_name
[__PMAX
];
1687 char dll_name
[__PMAX
];
1690 if (GetModuleInformation (current_process_handle
, hmodules
[i
],
1691 &mi
, sizeof (mi
)) == 0)
1693 if (GetModuleFileNameEx (current_process_handle
, hmodules
[i
],
1694 dll_name
, sizeof (dll_name
)) == 0)
1697 wcstombs (name
, dll_name
, __PMAX
);
1702 solib_end
->next
= windows_make_so (name
, mi
.lpBaseOfDll
);
1703 solib_end
= solib_end
->next
;
1708 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1710 extern int stop_after_trap
;
1712 struct inferior
*inf
;
1713 struct thread_info
*tp
;
1715 last_sig
= GDB_SIGNAL_0
;
1717 exception_count
= 0;
1718 open_process_used
= 0;
1719 debug_registers_changed
= 0;
1720 debug_registers_used
= 0;
1721 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1724 cygwin_load_start
= cygwin_load_end
= 0;
1726 current_event
.dwProcessId
= pid
;
1727 memset (¤t_event
, 0, sizeof (current_event
));
1728 if (!target_is_pushed (ops
))
1730 disable_breakpoints_in_shlibs ();
1731 windows_clear_solib ();
1732 clear_proceed_status (0);
1733 init_wait_for_inferior ();
1735 inf
= current_inferior ();
1736 inferior_appeared (inf
, pid
);
1737 inf
->attach_flag
= attaching
;
1739 /* Make the new process the current inferior, so terminal handling
1740 can rely on it. When attaching, we don't know about any thread
1741 id here, but that's OK --- nothing should be referencing the
1742 current thread until we report an event out of windows_wait. */
1743 inferior_ptid
= pid_to_ptid (pid
);
1745 child_terminal_init_with_pgrp (pid
);
1746 target_terminal_inferior ();
1748 windows_initialization_done
= 0;
1749 inf
->control
.stop_soon
= STOP_QUIETLY
;
1752 stop_after_trap
= 1;
1753 wait_for_inferior ();
1754 tp
= inferior_thread ();
1755 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1756 resume (0, tp
->suspend
.stop_signal
);
1761 /* Now that the inferior has been started and all DLLs have been mapped,
1762 we can iterate over all DLLs and load them in.
1764 We avoid doing it any earlier because, on certain versions of Windows,
1765 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1766 we have seen on Windows 8.1 that the ntdll.dll load event does not
1767 include the DLL name, preventing us from creating an associated SO.
1768 A possible explanation is that ntdll.dll might be mapped before
1769 the SO info gets created by the Windows system -- ntdll.dll is
1770 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1771 do not seem to suffer from that problem.
1773 Rather than try to work around this sort of issue, it is much
1774 simpler to just ignore DLL load/unload events during the startup
1775 phase, and then process them all in one batch now. */
1776 windows_add_all_dlls ();
1778 windows_initialization_done
= 1;
1779 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1780 stop_after_trap
= 0;
1784 /* Try to set or remove a user privilege to the current process. Return -1
1785 if that fails, the previous setting of that privilege otherwise.
1787 This code is copied from the Cygwin source code and rearranged to allow
1788 dynamically loading of the needed symbols from advapi32 which is only
1789 available on NT/2K/XP. */
1791 set_process_privilege (const char *privilege
, BOOL enable
)
1793 HANDLE token_hdl
= NULL
;
1795 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1799 if (!OpenProcessToken (GetCurrentProcess (),
1800 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1804 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1807 new_priv
.PrivilegeCount
= 1;
1808 new_priv
.Privileges
[0].Luid
= restore_priv
;
1809 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1811 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1812 sizeof orig_priv
, &orig_priv
, &size
))
1815 /* Disabled, otherwise every `attach' in an unprivileged user session
1816 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1817 windows_attach(). */
1818 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1819 be enabled. GetLastError () returns an correct error code, though. */
1820 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1824 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1828 CloseHandle (token_hdl
);
1833 /* Attach to process PID, then initialize for debugging it. */
1835 windows_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1840 pid
= parse_pid_to_attach (args
);
1842 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1844 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1845 printf_unfiltered ("This can cause attach to "
1846 "fail on Windows NT/2K/XP\n");
1849 windows_init_thread_list ();
1850 ok
= DebugActiveProcess (pid
);
1856 /* Try fall back to Cygwin pid. */
1857 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1860 ok
= DebugActiveProcess (pid
);
1865 error (_("Can't attach to process."));
1867 DebugSetProcessKillOnExit (FALSE
);
1871 char *exec_file
= (char *) get_exec_file (0);
1874 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1875 target_pid_to_str (pid_to_ptid (pid
)));
1877 printf_unfiltered ("Attaching to %s\n",
1878 target_pid_to_str (pid_to_ptid (pid
)));
1880 gdb_flush (gdb_stdout
);
1883 do_initial_windows_stuff (ops
, pid
, 1);
1884 target_terminal_ours ();
1888 windows_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1893 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1895 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1897 error (_("Can't detach process %u (error %u)"),
1898 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1901 DebugSetProcessKillOnExit (FALSE
);
1903 if (detached
&& from_tty
)
1905 char *exec_file
= get_exec_file (0);
1908 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1909 (unsigned) current_event
.dwProcessId
);
1910 gdb_flush (gdb_stdout
);
1913 i386_cleanup_dregs ();
1914 inferior_ptid
= null_ptid
;
1915 detach_inferior (current_event
.dwProcessId
);
1917 inf_child_maybe_unpush_target (ops
);
1920 /* Try to determine the executable filename.
1922 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1924 Upon success, the filename is stored inside EXE_NAME_RET, and
1925 this function returns nonzero.
1927 Otherwise, this function returns zero and the contents of
1928 EXE_NAME_RET is undefined. */
1931 windows_get_exec_module_filename (char *exe_name_ret
, size_t exe_name_max_len
)
1938 if (!EnumProcessModules (current_process_handle
, &dh_buf
,
1939 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
1942 /* We know the executable is always first in the list of modules,
1943 which we just fetched. So no need to fetch more. */
1947 /* Cygwin prefers that the path be in /x/y/z format, so extract
1948 the filename into a temporary buffer first, and then convert it
1949 to POSIX format into the destination buffer. */
1950 cygwin_buf_t
*pathbuf
= alloca (exe_name_max_len
* sizeof (cygwin_buf_t
));
1952 len
= GetModuleFileNameEx (current_process_handle
,
1953 dh_buf
, pathbuf
, exe_name_max_len
);
1955 error (_("Error getting executable filename: %u."),
1956 (unsigned) GetLastError ());
1957 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, exe_name_ret
,
1958 exe_name_max_len
) < 0)
1959 error (_("Error converting executable filename to POSIX: %d."), errno
);
1962 len
= GetModuleFileNameEx (current_process_handle
,
1963 dh_buf
, exe_name_ret
, exe_name_max_len
);
1965 error (_("Error getting executable filename: %u."),
1966 (unsigned) GetLastError ());
1969 return 1; /* success */
1972 /* The pid_to_exec_file target_ops method for this platform. */
1975 windows_pid_to_exec_file (struct target_ops
*self
, int pid
)
1977 static char path
[__PMAX
];
1979 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1981 char procexe
[sizeof ("/proc/4294967295/exe")];
1983 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1984 nchars
= readlink (procexe
, path
, sizeof(path
));
1985 if (nchars
> 0 && nchars
< sizeof (path
))
1987 path
[nchars
] = '\0'; /* Got it */
1992 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1993 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1994 if (!windows_get_exec_module_filename (path
, sizeof (path
)))
2000 /* Print status information about what we're accessing. */
2003 windows_files_info (struct target_ops
*ignore
)
2005 struct inferior
*inf
= current_inferior ();
2007 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2008 inf
->attach_flag
? "attached" : "child",
2009 target_pid_to_str (inferior_ptid
));
2012 /* Modify CreateProcess parameters for use of a new separate console.
2014 *FLAGS: DWORD parameter for general process creation flags.
2015 *SI: STARTUPINFO structure, for which the console window size and
2016 console buffer size is filled in if GDB is running in a console.
2017 to create the new console.
2018 The size of the used font is not available on all versions of
2019 Windows OS. Furthermore, the current font might not be the default
2020 font, but this is still better than before.
2021 If the windows and buffer sizes are computed,
2022 SI->DWFLAGS is changed so that this information is used
2023 by CreateProcess function. */
2026 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
2028 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
2029 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2031 if (hconsole
!= INVALID_HANDLE_VALUE
)
2033 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
2035 CONSOLE_FONT_INFO cfi
;
2037 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
2038 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
2039 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
2040 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
2041 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
2043 si
->dwXSize
*= font_size
.X
;
2047 si
->dwYSize
*= font_size
.Y
;
2050 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
2051 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
2052 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
2054 *flags
|= CREATE_NEW_CONSOLE
;
2058 /* Function called by qsort to sort environment strings. */
2061 envvar_cmp (const void *a
, const void *b
)
2063 const char **p
= (const char **) a
;
2064 const char **q
= (const char **) b
;
2065 return strcasecmp (*p
, *q
);
2071 clear_win32_environment (char **env
)
2075 wchar_t *copy
= NULL
, *equalpos
;
2077 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2079 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2080 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2081 mbstowcs (copy
, env
[i
], len
);
2082 equalpos
= wcschr (copy
, L
'=');
2085 SetEnvironmentVariableW (copy
, NULL
);
2091 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2092 EXEC_FILE is the file to run.
2093 ALLARGS is a string containing the arguments to the program.
2094 ENV is the environment vector to pass. Errors reported with error(). */
2097 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2098 char *allargs
, char **in_env
, int from_tty
)
2102 cygwin_buf_t real_path
[__PMAX
];
2103 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2105 cygwin_buf_t
*toexec
;
2106 cygwin_buf_t
*cygallargs
;
2108 char **old_env
= NULL
;
2112 int ostdin
, ostdout
, ostderr
;
2114 char real_path
[__PMAX
];
2115 char shell
[__PMAX
]; /* Path to shell */
2127 PROCESS_INFORMATION pi
;
2130 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2133 error (_("No executable specified, use `target exec'."));
2135 memset (&si
, 0, sizeof (si
));
2136 si
.cb
= sizeof (si
);
2139 flags
|= CREATE_NEW_PROCESS_GROUP
;
2142 windows_set_console_info (&si
, &flags
);
2147 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2148 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2149 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2150 error (_("Error starting executable: %d"), errno
);
2153 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2154 if (len
== (size_t) -1)
2155 error (_("Error starting executable: %d"), errno
);
2156 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2157 mbstowcs (cygallargs
, allargs
, len
);
2159 cygallargs
= allargs
;
2164 sh
= getenv ("SHELL");
2167 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2168 error (_("Error starting executable via shell: %d"), errno
);
2170 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2171 + mbstowcs (NULL
, allargs
, 0) + 2;
2172 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2173 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2175 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2176 + strlen (allargs
) + 2);
2177 cygallargs
= (char *) alloca (len
);
2178 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2181 flags
|= DEBUG_PROCESS
;
2185 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2186 * sizeof (wchar_t));
2187 wcscpy (args
, toexec
);
2188 wcscat (args
, L
" ");
2189 wcscat (args
, cygallargs
);
2191 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2192 strcpy (args
, toexec
);
2194 strcat (args
, cygallargs
);
2197 #ifdef CW_CVT_ENV_TO_WINENV
2198 /* First try to create a direct Win32 copy of the POSIX environment. */
2199 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2200 if (w32_env
!= (PWCHAR
) -1)
2201 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2203 /* If that fails, fall back to old method tweaking GDB's environment. */
2206 /* Reset all Win32 environment variables to avoid leftover on next run. */
2207 clear_win32_environment (environ
);
2208 /* Prepare the environment vars for CreateProcess. */
2211 cygwin_internal (CW_SYNC_WINENV
);
2215 if (!inferior_io_terminal
)
2216 tty
= ostdin
= ostdout
= ostderr
= -1;
2219 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2222 print_sys_errmsg (inferior_io_terminal
, errno
);
2223 ostdin
= ostdout
= ostderr
= -1;
2236 windows_init_thread_list ();
2237 ret
= CreateProcess (0,
2238 args
, /* command line */
2239 NULL
, /* Security */
2241 TRUE
, /* inherit handles */
2242 flags
, /* start flags */
2243 w32_env
, /* environment */
2244 NULL
, /* current directory */
2248 /* Just free the Win32 environment, if it could be created. */
2252 /* Reset all environment variables to avoid leftover on next run. */
2253 clear_win32_environment (in_env
);
2254 /* Restore normal GDB environment variables. */
2256 cygwin_internal (CW_SYNC_WINENV
);
2271 /* Build the command line, a space-separated list of tokens where
2272 the first token is the name of the module to be executed.
2273 To avoid ambiguities introduced by spaces in the module name,
2275 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2276 args
= alloca (args_len
);
2277 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2279 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2281 if (!inferior_io_terminal
)
2282 tty
= INVALID_HANDLE_VALUE
;
2285 SECURITY_ATTRIBUTES sa
;
2286 sa
.nLength
= sizeof(sa
);
2287 sa
.lpSecurityDescriptor
= 0;
2288 sa
.bInheritHandle
= TRUE
;
2289 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2290 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2291 if (tty
== INVALID_HANDLE_VALUE
)
2292 warning (_("Warning: Failed to open TTY %s, error %#x."),
2293 inferior_io_terminal
, (unsigned) GetLastError ());
2297 si
.hStdOutput
= tty
;
2299 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2303 /* CreateProcess takes the environment list as a null terminated set of
2304 strings (i.e. two nulls terminate the list). */
2306 /* Get total size for env strings. */
2307 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2308 envlen
+= strlen (in_env
[i
]) + 1;
2310 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2311 env
= (char **) alloca (envsize
);
2312 memcpy (env
, in_env
, envsize
);
2313 /* Windows programs expect the environment block to be sorted. */
2314 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2316 w32env
= alloca (envlen
+ 1);
2318 /* Copy env strings into new buffer. */
2319 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2321 strcpy (temp
, env
[i
]);
2322 temp
+= strlen (temp
) + 1;
2325 /* Final nil string to terminate new env. */
2328 windows_init_thread_list ();
2329 ret
= CreateProcessA (0,
2330 args
, /* command line */
2331 NULL
, /* Security */
2333 TRUE
, /* inherit handles */
2334 flags
, /* start flags */
2335 w32env
, /* environment */
2336 NULL
, /* current directory */
2339 if (tty
!= INVALID_HANDLE_VALUE
)
2344 error (_("Error creating process %s, (error %u)."),
2345 exec_file
, (unsigned) GetLastError ());
2347 CloseHandle (pi
.hThread
);
2348 CloseHandle (pi
.hProcess
);
2350 if (useshell
&& shell
[0] != '\0')
2355 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2357 /* windows_continue (DBG_CONTINUE, -1, 0); */
2361 windows_mourn_inferior (struct target_ops
*ops
)
2363 (void) windows_continue (DBG_CONTINUE
, -1, 0);
2364 i386_cleanup_dregs();
2365 if (open_process_used
)
2367 CHECK (CloseHandle (current_process_handle
));
2368 open_process_used
= 0;
2370 inf_child_mourn_inferior (ops
);
2373 /* Send a SIGINT to the process group. This acts just like the user typed a
2374 ^C on the controlling terminal. */
2377 windows_stop (struct target_ops
*self
, ptid_t ptid
)
2379 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2380 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2381 registers_changed (); /* refresh register state */
2384 /* Helper for windows_xfer_partial that handles memory transfers.
2385 Arguments are like target_xfer_partial. */
2387 static enum target_xfer_status
2388 windows_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2389 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2393 DWORD lasterror
= 0;
2395 if (writebuf
!= NULL
)
2397 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2398 pulongest (len
), core_addr_to_string (memaddr
)));
2399 success
= WriteProcessMemory (current_process_handle
,
2400 (LPVOID
) (uintptr_t) memaddr
, writebuf
,
2403 lasterror
= GetLastError ();
2404 FlushInstructionCache (current_process_handle
,
2405 (LPCVOID
) (uintptr_t) memaddr
, len
);
2409 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2410 pulongest (len
), core_addr_to_string (memaddr
)));
2411 success
= ReadProcessMemory (current_process_handle
,
2412 (LPCVOID
) (uintptr_t) memaddr
, readbuf
,
2415 lasterror
= GetLastError ();
2417 *xfered_len
= (ULONGEST
) done
;
2418 if (!success
&& lasterror
== ERROR_PARTIAL_COPY
&& done
> 0)
2419 return TARGET_XFER_OK
;
2421 return success
? TARGET_XFER_OK
: TARGET_XFER_E_IO
;
2425 windows_kill_inferior (struct target_ops
*ops
)
2427 CHECK (TerminateProcess (current_process_handle
, 0));
2431 if (!windows_continue (DBG_CONTINUE
, -1, 1))
2433 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2435 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2439 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2443 windows_close (struct target_ops
*self
)
2445 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2446 ptid_get_pid (inferior_ptid
)));
2449 /* Convert pid to printable format. */
2451 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2453 static char buf
[80];
2455 if (ptid_get_tid (ptid
) != 0)
2457 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2458 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2462 return normal_pid_to_str (ptid
);
2465 static enum target_xfer_status
2466 windows_xfer_shared_libraries (struct target_ops
*ops
,
2467 enum target_object object
, const char *annex
,
2468 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2469 ULONGEST offset
, ULONGEST len
,
2470 ULONGEST
*xfered_len
)
2472 struct obstack obstack
;
2478 return TARGET_XFER_E_IO
;
2480 obstack_init (&obstack
);
2481 obstack_grow_str (&obstack
, "<library-list>\n");
2482 for (so
= solib_start
.next
; so
; so
= so
->next
)
2483 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2484 (uintptr_t) so
->lm_info
->load_addr
,
2485 target_gdbarch (), &obstack
);
2486 obstack_grow_str0 (&obstack
, "</library-list>\n");
2488 buf
= obstack_finish (&obstack
);
2489 len_avail
= strlen (buf
);
2490 if (offset
>= len_avail
)
2494 if (len
> len_avail
- offset
)
2495 len
= len_avail
- offset
;
2496 memcpy (readbuf
, buf
+ offset
, len
);
2499 obstack_free (&obstack
, NULL
);
2500 *xfered_len
= (ULONGEST
) len
;
2501 return len
!= 0 ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
2504 static enum target_xfer_status
2505 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2506 const char *annex
, gdb_byte
*readbuf
,
2507 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2508 ULONGEST
*xfered_len
)
2512 case TARGET_OBJECT_MEMORY
:
2513 return windows_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2515 case TARGET_OBJECT_LIBRARIES
:
2516 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2517 writebuf
, offset
, len
, xfered_len
);
2520 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2521 readbuf
, writebuf
, offset
, len
,
2526 /* Provide thread local base, i.e. Thread Information Block address.
2527 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2530 windows_get_tib_address (struct target_ops
*self
,
2531 ptid_t ptid
, CORE_ADDR
*addr
)
2535 th
= thread_rec (ptid_get_tid (ptid
), 0);
2540 *addr
= th
->thread_local_base
;
2546 windows_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2548 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2551 static struct target_ops
*
2552 windows_target (void)
2554 struct target_ops
*t
= inf_child_target ();
2556 t
->to_close
= windows_close
;
2557 t
->to_attach
= windows_attach
;
2558 t
->to_attach_no_wait
= 1;
2559 t
->to_detach
= windows_detach
;
2560 t
->to_resume
= windows_resume
;
2561 t
->to_wait
= windows_wait
;
2562 t
->to_fetch_registers
= windows_fetch_inferior_registers
;
2563 t
->to_store_registers
= windows_store_inferior_registers
;
2564 t
->to_xfer_partial
= windows_xfer_partial
;
2565 t
->to_files_info
= windows_files_info
;
2566 t
->to_kill
= windows_kill_inferior
;
2567 t
->to_create_inferior
= windows_create_inferior
;
2568 t
->to_mourn_inferior
= windows_mourn_inferior
;
2569 t
->to_thread_alive
= windows_thread_alive
;
2570 t
->to_pid_to_str
= windows_pid_to_str
;
2571 t
->to_stop
= windows_stop
;
2572 t
->to_pid_to_exec_file
= windows_pid_to_exec_file
;
2573 t
->to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2574 t
->to_get_tib_address
= windows_get_tib_address
;
2580 set_windows_aliases (char *argv0
)
2582 add_info_alias ("dll", "sharedlibrary", 1);
2585 /* -Wmissing-prototypes */
2586 extern initialize_file_ftype _initialize_windows_nat
;
2589 _initialize_windows_nat (void)
2591 struct cmd_list_element
*c
;
2592 struct target_ops
*t
;
2594 t
= windows_target ();
2596 i386_use_watchpoints (t
);
2598 i386_dr_low
.set_control
= cygwin_set_dr7
;
2599 i386_dr_low
.set_addr
= cygwin_set_dr
;
2600 i386_dr_low
.get_addr
= cygwin_get_dr
;
2601 i386_dr_low
.get_status
= cygwin_get_dr6
;
2602 i386_dr_low
.get_control
= cygwin_get_dr7
;
2604 /* i386_dr_low.debug_register_length field is set by
2605 calling i386_set_debug_register_length function
2606 in processor windows specific native file. */
2611 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2614 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2615 _("Load dll library symbols from FILE."));
2616 set_cmd_completer (c
, filename_completer
);
2617 deprecate_cmd (c
, "sharedlibrary");
2619 c
= add_com ("add-shared-symbol-files", class_files
, dll_symbol_command
,
2620 _("Load dll library symbols from FILE."));
2621 set_cmd_completer (c
, filename_completer
);
2622 deprecate_cmd (c
, "sharedlibrary");
2624 c
= add_com ("assf", class_files
, dll_symbol_command
,
2625 _("Load dll library symbols from FILE."));
2626 set_cmd_completer (c
, filename_completer
);
2627 deprecate_cmd (c
, "sharedlibrary");
2630 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2631 Set use of shell to start subprocess."), _("\
2632 Show use of shell to start subprocess."), NULL
,
2634 NULL
, /* FIXME: i18n: */
2635 &setlist
, &showlist
);
2637 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2638 &cygwin_exceptions
, _("\
2639 Break when an exception is detected in the Cygwin DLL itself."), _("\
2640 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2642 NULL
, /* FIXME: i18n: */
2643 &setlist
, &showlist
);
2646 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2647 Set creation of new console when creating child process."), _("\
2648 Show creation of new console when creating child process."), NULL
,
2650 NULL
, /* FIXME: i18n: */
2651 &setlist
, &showlist
);
2653 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2654 Set creation of new group when creating child process."), _("\
2655 Show creation of new group when creating child process."), NULL
,
2657 NULL
, /* FIXME: i18n: */
2658 &setlist
, &showlist
);
2660 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2661 Set whether to display execution in child process."), _("\
2662 Show whether to display execution in child process."), NULL
,
2664 NULL
, /* FIXME: i18n: */
2665 &setlist
, &showlist
);
2667 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2668 Set whether to display kernel events in child process."), _("\
2669 Show whether to display kernel events in child process."), NULL
,
2671 NULL
, /* FIXME: i18n: */
2672 &setlist
, &showlist
);
2674 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2675 Set whether to display memory accesses in child process."), _("\
2676 Show whether to display memory accesses in child process."), NULL
,
2678 NULL
, /* FIXME: i18n: */
2679 &setlist
, &showlist
);
2681 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2682 &debug_exceptions
, _("\
2683 Set whether to display kernel exceptions in child process."), _("\
2684 Show whether to display kernel exceptions in child process."), NULL
,
2686 NULL
, /* FIXME: i18n: */
2687 &setlist
, &showlist
);
2689 init_w32_command_list ();
2691 add_cmd ("selector", class_info
, display_selectors
,
2692 _("Display selectors infos."),
2694 deprecated_init_ui_hook
= set_windows_aliases
;
2697 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2699 /* Pass the address ADDR to the inferior in the I'th debug register.
2700 Here we just store the address in dr array, the registers will be
2701 actually set up when windows_continue is called. */
2703 cygwin_set_dr (int i
, CORE_ADDR addr
)
2706 internal_error (__FILE__
, __LINE__
,
2707 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2709 debug_registers_changed
= 1;
2710 debug_registers_used
= 1;
2713 /* Pass the value VAL to the inferior in the DR7 debug control
2714 register. Here we just store the address in D_REGS, the watchpoint
2715 will be actually set up in windows_wait. */
2717 cygwin_set_dr7 (unsigned long val
)
2719 dr
[7] = (CORE_ADDR
) val
;
2720 debug_registers_changed
= 1;
2721 debug_registers_used
= 1;
2724 /* Get the value of debug register I from the inferior. */
2727 cygwin_get_dr (int i
)
2732 /* Get the value of the DR6 debug status register from the inferior.
2733 Here we just return the value stored in dr[6]
2734 by the last call to thread_rec for current_event.dwThreadId id. */
2735 static unsigned long
2736 cygwin_get_dr6 (void)
2738 return (unsigned long) dr
[6];
2741 /* Get the value of the DR7 debug status register from the inferior.
2742 Here we just return the value stored in dr[7] by the last call to
2743 thread_rec for current_event.dwThreadId id. */
2745 static unsigned long
2746 cygwin_get_dr7 (void)
2748 return (unsigned long) dr
[7];
2751 /* Determine if the thread referenced by "ptid" is alive
2752 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2753 it means that the thread has died. Otherwise it is assumed to be alive. */
2755 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2759 gdb_assert (ptid_get_tid (ptid
) != 0);
2760 tid
= ptid_get_tid (ptid
);
2762 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2766 /* -Wmissing-prototypes */
2767 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2770 _initialize_check_for_gdb_ini (void)
2773 if (inhibit_gdbinit
)
2776 homedir
= getenv ("HOME");
2780 char *oldini
= (char *) alloca (strlen (homedir
) +
2781 sizeof ("/gdb.ini"));
2782 strcpy (oldini
, homedir
);
2783 p
= strchr (oldini
, '\0');
2784 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2786 strcpy (p
, "gdb.ini");
2787 if (access (oldini
, 0) == 0)
2789 int len
= strlen (oldini
);
2790 char *newini
= alloca (len
+ 1);
2792 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2793 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2794 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2799 /* Define dummy functions which always return error for the rare cases where
2800 these functions could not be found. */
2802 bad_DebugActiveProcessStop (DWORD w
)
2807 bad_DebugBreakProcess (HANDLE w
)
2812 bad_DebugSetProcessKillOnExit (BOOL w
)
2817 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2824 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2830 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2837 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2843 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2849 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2855 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2863 /* -Wmissing-prototypes */
2864 extern initialize_file_ftype _initialize_loadable
;
2866 /* Load any functions which may not be available in ancient versions
2870 _initialize_loadable (void)
2874 hm
= LoadLibrary ("kernel32.dll");
2877 DebugActiveProcessStop
= (void *)
2878 GetProcAddress (hm
, "DebugActiveProcessStop");
2879 DebugBreakProcess
= (void *)
2880 GetProcAddress (hm
, "DebugBreakProcess");
2881 DebugSetProcessKillOnExit
= (void *)
2882 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2883 GetConsoleFontSize
= (void *)
2884 GetProcAddress (hm
, "GetConsoleFontSize");
2885 GetCurrentConsoleFont
= (void *)
2886 GetProcAddress (hm
, "GetCurrentConsoleFont");
2889 /* Set variables to dummy versions of these processes if the function
2890 wasn't found in kernel32.dll. */
2891 if (!DebugBreakProcess
)
2892 DebugBreakProcess
= bad_DebugBreakProcess
;
2893 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2895 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2896 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2898 if (!GetConsoleFontSize
)
2899 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2900 if (!GetCurrentConsoleFont
)
2901 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2903 /* Load optional functions used for retrieving filename information
2904 associated with the currently debugged process or its dlls. */
2905 hm
= LoadLibrary ("psapi.dll");
2908 EnumProcessModules
= (void *)
2909 GetProcAddress (hm
, "EnumProcessModules");
2910 GetModuleInformation
= (void *)
2911 GetProcAddress (hm
, "GetModuleInformation");
2912 GetModuleFileNameEx
= (void *)
2913 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2916 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2918 /* Set variables to dummy versions of these processes if the function
2919 wasn't found in psapi.dll. */
2920 EnumProcessModules
= bad_EnumProcessModules
;
2921 GetModuleInformation
= bad_GetModuleInformation
;
2922 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2923 /* This will probably fail on Windows 9x/Me. Let the user know
2924 that we're missing some functionality. */
2926 cannot automatically find executable file or library to read symbols.\n\
2927 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2930 hm
= LoadLibrary ("advapi32.dll");
2933 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2934 LookupPrivilegeValueA
= (void *)
2935 GetProcAddress (hm
, "LookupPrivilegeValueA");
2936 AdjustTokenPrivileges
= (void *)
2937 GetProcAddress (hm
, "AdjustTokenPrivileges");
2938 /* Only need to set one of these since if OpenProcessToken fails nothing
2940 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2941 || !AdjustTokenPrivileges
)
2942 OpenProcessToken
= bad_OpenProcessToken
;