1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2013 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 */
28 #include "exceptions.h"
31 #include "completer.h"
35 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
49 #include "filenames.h"
53 #include "gdb_obstack.h"
54 #include "gdb_string.h"
55 #include "gdbthread.h"
57 #include <sys/param.h>
62 #include "xml-support.h"
64 #include "i386-tdep.h"
65 #include "i387-tdep.h"
67 #include "windows-tdep.h"
68 #include "windows-nat.h"
70 #include "complaints.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
84 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
85 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
86 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
87 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
88 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
90 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
92 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
93 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
94 static BOOL
WINAPI (*GetCurrentConsoleFont
) (HANDLE
, BOOL
,
96 static COORD
WINAPI (*GetConsoleFontSize
) (HANDLE
, DWORD
);
98 static struct target_ops windows_ops
;
102 #undef GetModuleFileNameEx
105 # define __PMAX (MAX_PATH + 1)
106 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
107 # define STARTUPINFO STARTUPINFOA
108 # define CreateProcess CreateProcessA
109 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
110 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
112 # define __PMAX PATH_MAX
113 /* The starting and ending address of the cygwin1.dll text segment. */
114 static CORE_ADDR cygwin_load_start
;
115 static CORE_ADDR cygwin_load_end
;
117 typedef wchar_t cygwin_buf_t
;
118 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
,
120 # define STARTUPINFO STARTUPINFOW
121 # define CreateProcess CreateProcessW
122 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
123 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
126 static int have_saved_context
; /* True if we've saved context from a
128 static CONTEXT saved_context
; /* Containes the saved context from a
131 /* If we're not using the old Cygwin header file set, define the
132 following which never should have been in the generic Win32 API
133 headers in the first place since they were our own invention... */
134 #ifndef _GNU_H_WINDOWS_H
137 FLAG_TRACE_BIT
= 0x100,
138 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
142 #ifndef CONTEXT_EXTENDED_REGISTERS
143 /* This macro is only defined on ia32. It only makes sense on this target,
144 so define it as zero if not already defined. */
145 #define CONTEXT_EXTENDED_REGISTERS 0
148 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
149 | CONTEXT_EXTENDED_REGISTERS
151 static uintptr_t dr
[8];
152 static int debug_registers_changed
;
153 static int debug_registers_used
;
155 static int windows_initialization_done
;
156 #define DR6_CLEAR_VALUE 0xffff0ff0
158 /* The string sent by cygwin when it processes a signal.
159 FIXME: This should be in a cygwin include file. */
160 #ifndef _CYGWIN_SIGNAL_STRING
161 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
164 #define CHECK(x) check (x, __FILE__,__LINE__)
165 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
166 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
167 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
168 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
170 static void windows_stop (ptid_t
);
171 static int windows_thread_alive (struct target_ops
*, ptid_t
);
172 static void windows_kill_inferior (struct target_ops
*);
174 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
175 static void cygwin_set_dr7 (unsigned long val
);
176 static CORE_ADDR
cygwin_get_dr (int i
);
177 static unsigned long cygwin_get_dr6 (void);
178 static unsigned long cygwin_get_dr7 (void);
180 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
181 /* Set if a signal was received from the debugged process. */
183 /* Thread information structure used to track information that is
184 not available in gdb's thread structure. */
185 typedef struct thread_info_struct
187 struct thread_info_struct
*next
;
190 CORE_ADDR thread_local_base
;
199 static thread_info thread_head
;
201 /* The process and thread handles for the above context. */
203 static DEBUG_EVENT current_event
; /* The current debug event from
205 static HANDLE current_process_handle
; /* Currently executing process */
206 static thread_info
*current_thread
; /* Info on currently selected thread */
207 static DWORD main_thread_id
; /* Thread ID of the main thread */
209 /* Counts of things. */
210 static int exception_count
= 0;
211 static int event_count
= 0;
212 static int saw_create
;
213 static int open_process_used
= 0;
216 static int new_console
= 0;
218 static int cygwin_exceptions
= 0;
220 static int new_group
= 1;
221 static int debug_exec
= 0; /* show execution */
222 static int debug_events
= 0; /* show events from kernel */
223 static int debug_memory
= 0; /* show target memory accesses */
224 static int debug_exceptions
= 0; /* show target exceptions */
225 static int useshell
= 0; /* use shell for subprocesses */
227 /* This vector maps GDB's idea of a register's number into an offset
228 in the windows exception context vector.
230 It also contains the bit mask needed to load the register in question.
232 The contents of this table can only be computed by the units
233 that provide CPU-specific support for Windows native debugging.
234 These units should set the table by calling
235 windows_set_context_register_offsets.
237 One day we could read a reg, we could inspect the context we
238 already have loaded, if it doesn't have the bit set that we need,
239 we read that set of registers in using GetThreadContext. If the
240 context already contains what we need, we just unpack it. Then to
241 write a register, first we have to ensure that the context contains
242 the other regs of the group, and then we copy the info in and set
245 static const int *mappings
;
247 /* The function to use in order to determine whether a register is
248 a segment register or not. */
249 static segment_register_p_ftype
*segment_register_p
;
251 /* This vector maps the target's idea of an exception (extracted
252 from the DEBUG_EVENT structure) to GDB's idea. */
254 struct xlate_exception
260 static const struct xlate_exception
263 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
264 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
265 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
266 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
267 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
268 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
271 /* Set the MAPPINGS static global to OFFSETS.
272 See the description of MAPPINGS for more details. */
275 windows_set_context_register_offsets (const int *offsets
)
280 /* See windows-nat.h. */
283 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
285 segment_register_p
= fun
;
289 check (BOOL ok
, const char *file
, int line
)
292 printf_filtered ("error return %s:%d was %u\n", file
, line
,
293 (unsigned) GetLastError ());
296 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
297 then also retrieve the context for this thread. If GET_CONTEXT is
298 negative, then don't suspend the thread. */
300 thread_rec (DWORD id
, int get_context
)
304 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
307 if (!th
->suspended
&& get_context
)
309 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
311 if (SuspendThread (th
->h
) == (DWORD
) -1)
313 DWORD err
= GetLastError ();
314 warning (_("SuspendThread failed. (winerr %u)"),
320 else if (get_context
< 0)
322 th
->reload_context
= 1;
330 /* Add a thread to the thread list. */
332 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
337 gdb_assert (ptid_get_tid (ptid
) != 0);
339 id
= ptid_get_tid (ptid
);
341 if ((th
= thread_rec (id
, FALSE
)))
344 th
= XZALLOC (thread_info
);
347 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
348 th
->next
= thread_head
.next
;
349 thread_head
.next
= th
;
351 /* Set the debug registers for the new thread if they are used. */
352 if (debug_registers_used
)
354 /* Only change the value of the debug registers. */
355 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
356 CHECK (GetThreadContext (th
->h
, &th
->context
));
357 th
->context
.Dr0
= dr
[0];
358 th
->context
.Dr1
= dr
[1];
359 th
->context
.Dr2
= dr
[2];
360 th
->context
.Dr3
= dr
[3];
361 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
362 th
->context
.Dr7
= dr
[7];
363 CHECK (SetThreadContext (th
->h
, &th
->context
));
364 th
->context
.ContextFlags
= 0;
369 /* Clear out any old thread list and reintialize it to a
372 windows_init_thread_list (void)
374 thread_info
*th
= &thread_head
;
376 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
378 while (th
->next
!= NULL
)
380 thread_info
*here
= th
->next
;
381 th
->next
= here
->next
;
384 thread_head
.next
= NULL
;
387 /* Delete a thread from the list of threads. */
389 windows_delete_thread (ptid_t ptid
)
394 gdb_assert (ptid_get_tid (ptid
) != 0);
396 id
= ptid_get_tid (ptid
);
399 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
400 delete_thread (ptid
);
402 for (th
= &thread_head
;
403 th
->next
!= NULL
&& th
->next
->id
!= id
;
407 if (th
->next
!= NULL
)
409 thread_info
*here
= th
->next
;
410 th
->next
= here
->next
;
416 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
418 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
419 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
420 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
424 return; /* Windows sometimes uses a non-existent thread id in its
427 if (current_thread
->reload_context
)
429 #ifdef __COPY_CONTEXT_SIZE
430 if (have_saved_context
)
432 /* Lie about where the program actually is stopped since
433 cygwin has informed us that we should consider the signal
434 to have occurred at another location which is stored in
436 memcpy (¤t_thread
->context
, &saved_context
,
437 __COPY_CONTEXT_SIZE
);
438 have_saved_context
= 0;
443 thread_info
*th
= current_thread
;
444 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
445 GetThreadContext (th
->h
, &th
->context
);
446 /* Copy dr values from that thread.
447 But only if there were not modified since last stop.
449 if (!debug_registers_changed
)
451 dr
[0] = th
->context
.Dr0
;
452 dr
[1] = th
->context
.Dr1
;
453 dr
[2] = th
->context
.Dr2
;
454 dr
[3] = th
->context
.Dr3
;
455 dr
[6] = th
->context
.Dr6
;
456 dr
[7] = th
->context
.Dr7
;
459 current_thread
->reload_context
= 0;
462 if (r
== I387_FISEG_REGNUM (tdep
))
464 l
= *((long *) context_offset
) & 0xffff;
465 regcache_raw_supply (regcache
, r
, (char *) &l
);
467 else if (r
== I387_FOP_REGNUM (tdep
))
469 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
470 regcache_raw_supply (regcache
, r
, (char *) &l
);
472 else if (segment_register_p (r
))
474 /* GDB treats segment registers as 32bit registers, but they are
475 in fact only 16 bits long. Make sure we do not read extra
476 bits from our source buffer. */
477 l
= *((long *) context_offset
) & 0xffff;
478 regcache_raw_supply (regcache
, r
, (char *) &l
);
481 regcache_raw_supply (regcache
, r
, context_offset
);
484 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
485 do_windows_fetch_inferior_registers (regcache
, r
);
490 windows_fetch_inferior_registers (struct target_ops
*ops
,
491 struct regcache
*regcache
, int r
)
493 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
494 /* Check if current_thread exists. Windows sometimes uses a non-existent
495 thread id in its events. */
497 do_windows_fetch_inferior_registers (regcache
, r
);
501 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
504 /* Windows sometimes uses a non-existent thread id in its events. */;
506 regcache_raw_collect (regcache
, r
,
507 ((char *) ¤t_thread
->context
) + mappings
[r
]);
510 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
511 do_windows_store_inferior_registers (regcache
, r
);
515 /* Store a new register value into the current thread context. */
517 windows_store_inferior_registers (struct target_ops
*ops
,
518 struct regcache
*regcache
, int r
)
520 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
521 /* Check if current_thread exists. Windows sometimes uses a non-existent
522 thread id in its events. */
524 do_windows_store_inferior_registers (regcache
, r
);
527 /* Get the name of a given module at given base address. If base_address
528 is zero return the first loaded module (which is always the name of the
531 get_module_name (LPVOID base_address
, char *dll_name_ret
)
537 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for
541 cygwin_buf_t pathbuf
[__PMAX
]; /* Temporary storage prior to converting to
542 posix form. __PMAX is always enough
543 as long as SO_NAME_MAX_PATH_SIZE is defined
548 /* Find size of buffer needed to handle list of modules loaded in
550 if (!EnumProcessModules (current_process_handle
, DllHandle
,
551 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
554 /* Allocate correct amount of space for module list. */
555 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
559 /* Get the list of modules. */
560 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
564 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
566 /* Get information on this module. */
567 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
569 error (_("Can't get module info"));
571 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
573 /* Try to find the name of the given module. */
575 /* Cygwin prefers that the path be in /x/y/z format. */
576 len
= GetModuleFileNameEx (current_process_handle
,
577 DllHandle
[i
], pathbuf
, __PMAX
);
579 error (_("Error getting dll name: %u."),
580 (unsigned) GetLastError ());
581 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
583 error (_("Error converting dll name to POSIX: %d."), errno
);
585 len
= GetModuleFileNameEx (current_process_handle
,
586 DllHandle
[i
], dll_name_ret
, __PMAX
);
588 error (_("Error getting dll name: %u."),
589 (unsigned) GetLastError ());
591 return 1; /* success */
596 dll_name_ret
[0] = '\0';
597 return 0; /* failure */
600 /* Encapsulate the information required in a call to
601 symbol_file_add_args. */
602 struct safe_symbol_file_add_args
606 struct section_addr_info
*addrs
;
609 struct ui_file
*err
, *out
;
613 /* Maintain a linked list of "so" information. */
619 static struct so_list solib_start
, *solib_end
;
621 /* Call symbol_file_add with stderr redirected. We don't care if there
624 safe_symbol_file_add_stub (void *argv
)
626 #define p ((struct safe_symbol_file_add_args *) argv)
627 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
628 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
629 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
634 /* Restore gdb's stderr after calling symbol_file_add. */
636 safe_symbol_file_add_cleanup (void *p
)
638 #define sp ((struct safe_symbol_file_add_args *)p)
639 gdb_flush (gdb_stderr
);
640 gdb_flush (gdb_stdout
);
641 ui_file_delete (gdb_stderr
);
642 ui_file_delete (gdb_stdout
);
643 gdb_stderr
= sp
->err
;
644 gdb_stdout
= sp
->out
;
648 /* symbol_file_add wrapper that prevents errors from being displayed. */
649 static struct objfile
*
650 safe_symbol_file_add (char *name
, int from_tty
,
651 struct section_addr_info
*addrs
,
652 int mainline
, int flags
)
654 struct safe_symbol_file_add_args p
;
655 struct cleanup
*cleanup
;
657 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
661 gdb_flush (gdb_stderr
);
662 gdb_flush (gdb_stdout
);
663 gdb_stderr
= ui_file_new ();
664 gdb_stdout
= ui_file_new ();
666 p
.from_tty
= from_tty
;
668 p
.mainline
= mainline
;
670 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
672 do_cleanups (cleanup
);
676 static struct so_list
*
677 windows_make_so (const char *name
, LPVOID load_addr
)
684 WIN32_FIND_DATA w32_fd
;
685 HANDLE h
= FindFirstFile(name
, &w32_fd
);
687 if (h
== INVALID_HANDLE_VALUE
)
693 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
695 p
= strrchr (buf
, '\\');
698 SetCurrentDirectory (buf
);
699 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
700 SetCurrentDirectory (cwd
);
703 if (strcasecmp (buf
, "ntdll.dll") == 0)
705 GetSystemDirectory (buf
, sizeof (buf
));
706 strcat (buf
, "\\ntdll.dll");
709 cygwin_buf_t buf
[__PMAX
];
712 if (access (name
, F_OK
) != 0)
714 if (strcasecmp (name
, "ntdll.dll") == 0)
717 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
718 wcscat (buf
, L
"\\ntdll.dll");
722 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
723 strcat (buf
, "\\ntdll.dll");
728 so
= XZALLOC (struct so_list
);
729 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
730 so
->lm_info
->load_addr
= load_addr
;
731 strcpy (so
->so_original_name
, name
);
733 strcpy (so
->so_name
, buf
);
736 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
737 SO_NAME_MAX_PATH_SIZE
);
740 char *rname
= realpath (name
, NULL
);
741 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
743 strcpy (so
->so_name
, rname
);
747 error (_("dll path too long"));
749 /* Record cygwin1.dll .text start/end. */
750 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
751 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
754 asection
*text
= NULL
;
757 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
762 if (bfd_check_format (abfd
, bfd_object
))
763 text
= bfd_get_section_by_name (abfd
, ".text");
767 gdb_bfd_unref (abfd
);
771 /* The symbols in a dll are offset by 0x1000, which is the
772 offset from 0 of the first byte in an image - because of the
773 file header and the section alignment. */
774 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
776 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
778 gdb_bfd_unref (abfd
);
786 get_image_name (HANDLE h
, void *address
, int unicode
)
789 static char buf
[__PMAX
];
791 static char buf
[(2 * __PMAX
) + 1];
793 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
799 /* Attempt to read the name of the dll that was detected.
800 This is documented to work only when actively debugging
801 a program. It will not work for attached processes. */
805 /* See if we could read the address of a string, and that the
806 address isn't null. */
807 if (!ReadProcessMemory (h
, address
, &address_ptr
,
808 sizeof (address_ptr
), &done
)
809 || done
!= sizeof (address_ptr
) || !address_ptr
)
812 /* Find the length of the string. */
813 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
814 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
818 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
821 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
822 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
825 wcstombs (buf
, unicode_address
, __PMAX
);
827 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
835 /* Wait for child to do something. Return pid of child, or -1 in case
836 of error; store status through argument pointer OURSTATUS. */
838 handle_load_dll (void *dummy
)
840 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
841 char dll_buf
[__PMAX
];
842 char *dll_name
= NULL
;
844 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
846 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
847 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
851 if (*dll_name
== '\0')
852 dll_name
= get_image_name (current_process_handle
,
853 event
->lpImageName
, event
->fUnicode
);
857 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
858 solib_end
= solib_end
->next
;
860 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
861 host_address_to_string (solib_end
->lm_info
->load_addr
)));
867 windows_free_so (struct so_list
*so
)
875 handle_unload_dll (void *dummy
)
877 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
880 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
881 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
883 struct so_list
*sodel
= so
->next
;
884 so
->next
= sodel
->next
;
887 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
889 windows_free_so (sodel
);
890 solib_add (NULL
, 0, NULL
, auto_solib_add
);
894 /* We did not find any DLL that was previously loaded at this address,
895 so register a complaint. We do not report an error, because we have
896 observed that this may be happening under some circumstances. For
897 instance, running 32bit applications on x64 Windows causes us to receive
898 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
899 events are apparently caused by the WOW layer, the interface between
900 32bit and 64bit worlds). */
901 complaint (&symfile_complaints
, _("dll starting at %s not found."),
902 host_address_to_string (lpBaseOfDll
));
907 /* Clear list of loaded DLLs. */
909 windows_clear_solib (void)
911 solib_start
.next
= NULL
;
912 solib_end
= &solib_start
;
915 /* Load DLL symbol info. */
917 dll_symbol_command (char *args
, int from_tty
)
923 error (_("dll-symbols requires a file name"));
926 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
928 char *newargs
= (char *) alloca (n
+ 4 + 1);
929 strcpy (newargs
, args
);
930 strcat (newargs
, ".dll");
934 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
937 /* Handle DEBUG_STRING output from child process.
938 Cygwin prepends its messages with a "cygwin:". Interpret this as
939 a Cygwin signal. Otherwise just print the string as a warning. */
941 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
946 if (!target_read_string
947 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
951 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
952 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
955 if (strncmp (s
, "cYg", 3) != 0)
959 #ifdef __COPY_CONTEXT_SIZE
962 /* Got a cygwin signal marker. A cygwin signal is followed by
963 the signal number itself and then optionally followed by the
964 thread id and address to saved context within the DLL. If
965 these are supplied, then the given thread is assumed to have
966 issued the signal and the context from the thread is assumed
967 to be stored at the given address in the inferior. Tell gdb
968 to treat this like a real signal. */
970 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
971 int gotasig
= gdb_signal_from_host (sig
);
973 ourstatus
->value
.sig
= gotasig
;
979 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
980 retval
= strtoul (p
, &p
, 0);
982 retval
= main_thread_id
;
983 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
984 && ReadProcessMemory (current_process_handle
, x
,
986 __COPY_CONTEXT_SIZE
, &n
)
987 && n
== __COPY_CONTEXT_SIZE
)
988 have_saved_context
= 1;
989 current_event
.dwThreadId
= retval
;
1000 display_selector (HANDLE thread
, DWORD sel
)
1003 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1006 printf_filtered ("0x%03x: ", (unsigned) sel
);
1007 if (!info
.HighWord
.Bits
.Pres
)
1009 puts_filtered ("Segment not present\n");
1012 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1013 (info
.HighWord
.Bits
.BaseMid
<< 16)
1015 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1016 if (info
.HighWord
.Bits
.Granularity
)
1017 limit
= (limit
<< 12) | 0xfff;
1018 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1019 if (info
.HighWord
.Bits
.Default_Big
)
1020 puts_filtered(" 32-bit ");
1022 puts_filtered(" 16-bit ");
1023 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1026 puts_filtered ("Data (Read-Only, Exp-up");
1029 puts_filtered ("Data (Read/Write, Exp-up");
1032 puts_filtered ("Unused segment (");
1035 puts_filtered ("Data (Read/Write, Exp-down");
1038 puts_filtered ("Code (Exec-Only, N.Conf");
1041 puts_filtered ("Code (Exec/Read, N.Conf");
1044 puts_filtered ("Code (Exec-Only, Conf");
1047 puts_filtered ("Code (Exec/Read, Conf");
1050 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1052 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1053 puts_filtered(", N.Acc");
1054 puts_filtered (")\n");
1055 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1056 puts_filtered("System selector ");
1057 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1058 if (info
.HighWord
.Bits
.Granularity
)
1059 puts_filtered ("Page granular.\n");
1061 puts_filtered ("Byte granular.\n");
1066 DWORD err
= GetLastError ();
1067 if (err
== ERROR_NOT_SUPPORTED
)
1068 printf_filtered ("Function not supported\n");
1070 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1076 display_selectors (char * args
, int from_tty
)
1078 if (!current_thread
)
1080 puts_filtered ("Impossible to display selectors now.\n");
1086 puts_filtered ("Selector $cs\n");
1087 display_selector (current_thread
->h
,
1088 current_thread
->context
.SegCs
);
1089 puts_filtered ("Selector $ds\n");
1090 display_selector (current_thread
->h
,
1091 current_thread
->context
.SegDs
);
1092 puts_filtered ("Selector $es\n");
1093 display_selector (current_thread
->h
,
1094 current_thread
->context
.SegEs
);
1095 puts_filtered ("Selector $ss\n");
1096 display_selector (current_thread
->h
,
1097 current_thread
->context
.SegSs
);
1098 puts_filtered ("Selector $fs\n");
1099 display_selector (current_thread
->h
,
1100 current_thread
->context
.SegFs
);
1101 puts_filtered ("Selector $gs\n");
1102 display_selector (current_thread
->h
,
1103 current_thread
->context
.SegGs
);
1108 sel
= parse_and_eval_long (args
);
1109 printf_filtered ("Selector \"%s\"\n",args
);
1110 display_selector (current_thread
->h
, sel
);
1114 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1115 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1116 host_address_to_string (\
1117 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1120 handle_exception (struct target_waitstatus
*ourstatus
)
1123 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1125 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1127 /* Record the context of the current thread. */
1128 th
= thread_rec (current_event
.dwThreadId
, -1);
1132 case EXCEPTION_ACCESS_VIOLATION
:
1133 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1134 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1137 /* See if the access violation happened within the cygwin DLL
1138 itself. Cygwin uses a kind of exception handling to deal
1139 with passed-in invalid addresses. gdb should not treat
1140 these as real SEGVs since they will be silently handled by
1141 cygwin. A real SEGV will (theoretically) be caught by
1142 cygwin later in the process and will be sent as a
1143 cygwin-specific-signal. So, ignore SEGVs if they show up
1144 within the text segment of the DLL itself. */
1146 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1147 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1149 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1150 && addr
< cygwin_load_end
))
1151 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1152 && strncmp (fn
, "KERNEL32!IsBad",
1153 strlen ("KERNEL32!IsBad")) == 0))
1158 case STATUS_STACK_OVERFLOW
:
1159 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1160 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1162 case STATUS_FLOAT_DENORMAL_OPERAND
:
1163 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1164 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1166 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1167 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1168 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1170 case STATUS_FLOAT_INEXACT_RESULT
:
1171 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1172 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1174 case STATUS_FLOAT_INVALID_OPERATION
:
1175 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1176 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1178 case STATUS_FLOAT_OVERFLOW
:
1179 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1180 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1182 case STATUS_FLOAT_STACK_CHECK
:
1183 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1184 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1186 case STATUS_FLOAT_UNDERFLOW
:
1187 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1188 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1190 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1191 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1192 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1194 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1195 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1196 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1198 case STATUS_INTEGER_OVERFLOW
:
1199 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1200 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1202 case EXCEPTION_BREAKPOINT
:
1203 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1204 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1207 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1208 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1210 case DBG_CONTROL_BREAK
:
1211 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1212 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1214 case EXCEPTION_SINGLE_STEP
:
1215 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1216 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1218 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1219 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1220 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1222 case EXCEPTION_PRIV_INSTRUCTION
:
1223 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1224 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1226 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1227 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1228 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1231 /* Treat unhandled first chance exceptions specially. */
1232 if (current_event
.u
.Exception
.dwFirstChance
)
1234 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1235 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1236 host_address_to_string (
1237 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1238 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1242 last_sig
= ourstatus
->value
.sig
;
1246 /* Resume all artificially suspended threads if we are continuing
1249 windows_continue (DWORD continue_status
, int id
)
1255 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%x, %s);\n",
1256 (unsigned) current_event
.dwProcessId
,
1257 (unsigned) current_event
.dwThreadId
,
1258 continue_status
== DBG_CONTINUE
?
1259 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1261 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1262 if ((id
== -1 || id
== (int) th
->id
)
1265 if (debug_registers_changed
)
1267 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1268 th
->context
.Dr0
= dr
[0];
1269 th
->context
.Dr1
= dr
[1];
1270 th
->context
.Dr2
= dr
[2];
1271 th
->context
.Dr3
= dr
[3];
1272 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1273 th
->context
.Dr7
= dr
[7];
1275 if (th
->context
.ContextFlags
)
1277 CHECK (SetThreadContext (th
->h
, &th
->context
));
1278 th
->context
.ContextFlags
= 0;
1280 if (th
->suspended
> 0)
1281 (void) ResumeThread (th
->h
);
1285 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1286 current_event
.dwThreadId
,
1289 debug_registers_changed
= 0;
1293 /* Called in pathological case where Windows fails to send a
1294 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1296 fake_create_process (void)
1298 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1299 current_event
.dwProcessId
);
1300 if (current_process_handle
!= NULL
)
1301 open_process_used
= 1;
1304 error (_("OpenProcess call failed, GetLastError = %u"),
1305 (unsigned) GetLastError ());
1306 /* We can not debug anything in that case. */
1308 main_thread_id
= current_event
.dwThreadId
;
1309 current_thread
= windows_add_thread (
1310 ptid_build (current_event
.dwProcessId
, 0,
1311 current_event
.dwThreadId
),
1312 current_event
.u
.CreateThread
.hThread
,
1313 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1314 return main_thread_id
;
1318 windows_resume (struct target_ops
*ops
,
1319 ptid_t ptid
, int step
, enum gdb_signal sig
)
1322 DWORD continue_status
= DBG_CONTINUE
;
1324 /* A specific PTID means `step only this thread id'. */
1325 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1327 /* If we're continuing all threads, it's the current inferior that
1328 should be handled specially. */
1330 ptid
= inferior_ptid
;
1332 if (sig
!= GDB_SIGNAL_0
)
1334 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1336 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1338 else if (sig
== last_sig
)
1339 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1342 /* This code does not seem to work, because
1343 the kernel does probably not consider changes in the ExceptionRecord
1344 structure when passing the exception to the inferior.
1345 Note that this seems possible in the exception handler itself. */
1348 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1349 if (xlate
[i
].us
== sig
)
1351 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1353 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1356 if (continue_status
== DBG_CONTINUE
)
1358 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1362 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1366 last_sig
= GDB_SIGNAL_0
;
1368 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1369 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1371 /* Get context for currently selected thread. */
1372 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1377 /* Single step by setting t bit. */
1378 struct regcache
*regcache
= get_current_regcache ();
1379 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1380 windows_fetch_inferior_registers (ops
, regcache
,
1381 gdbarch_ps_regnum (gdbarch
));
1382 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1385 if (th
->context
.ContextFlags
)
1387 if (debug_registers_changed
)
1389 th
->context
.Dr0
= dr
[0];
1390 th
->context
.Dr1
= dr
[1];
1391 th
->context
.Dr2
= dr
[2];
1392 th
->context
.Dr3
= dr
[3];
1393 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1394 th
->context
.Dr7
= dr
[7];
1396 CHECK (SetThreadContext (th
->h
, &th
->context
));
1397 th
->context
.ContextFlags
= 0;
1401 /* Allow continuing with the same signal that interrupted us.
1402 Otherwise complain. */
1405 windows_continue (continue_status
, -1);
1407 windows_continue (continue_status
, ptid_get_tid (ptid
));
1410 /* Ctrl-C handler used when the inferior is not run in the same console. The
1411 handler is in charge of interrupting the inferior using DebugBreakProcess.
1412 Note that this function is not available prior to Windows XP. In this case
1413 we emit a warning. */
1415 ctrl_c_handler (DWORD event_type
)
1417 const int attach_flag
= current_inferior ()->attach_flag
;
1419 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1420 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1423 /* If the inferior and the debugger share the same console, do nothing as
1424 the inferior has also received the Ctrl-C event. */
1425 if (!new_console
&& !attach_flag
)
1428 if (!DebugBreakProcess (current_process_handle
))
1429 warning (_("Could not interrupt program. "
1430 "Press Ctrl-c in the program console."));
1432 /* Return true to tell that Ctrl-C has been handled. */
1436 /* Get the next event from the child. Return 1 if the event requires
1437 handling by WFI (or whatever). */
1439 get_windows_debug_event (struct target_ops
*ops
,
1440 int pid
, struct target_waitstatus
*ourstatus
)
1443 DWORD continue_status
, event_code
;
1445 static thread_info dummy_thread_info
;
1448 last_sig
= GDB_SIGNAL_0
;
1450 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1454 continue_status
= DBG_CONTINUE
;
1456 event_code
= current_event
.dwDebugEventCode
;
1457 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1459 have_saved_context
= 0;
1463 case CREATE_THREAD_DEBUG_EVENT
:
1464 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1465 (unsigned) current_event
.dwProcessId
,
1466 (unsigned) current_event
.dwThreadId
,
1467 "CREATE_THREAD_DEBUG_EVENT"));
1468 if (saw_create
!= 1)
1470 struct inferior
*inf
;
1471 inf
= find_inferior_pid (current_event
.dwProcessId
);
1472 if (!saw_create
&& inf
->attach_flag
)
1474 /* Kludge around a Windows bug where first event is a create
1475 thread event. Caused when attached process does not have
1477 retval
= fake_create_process ();
1483 /* Record the existence of this thread. */
1484 retval
= current_event
.dwThreadId
;
1485 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1486 current_event
.dwThreadId
),
1487 current_event
.u
.CreateThread
.hThread
,
1488 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1492 case EXIT_THREAD_DEBUG_EVENT
:
1493 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1494 (unsigned) current_event
.dwProcessId
,
1495 (unsigned) current_event
.dwThreadId
,
1496 "EXIT_THREAD_DEBUG_EVENT"));
1498 if (current_event
.dwThreadId
!= main_thread_id
)
1500 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1501 current_event
.dwThreadId
));
1502 th
= &dummy_thread_info
;
1506 case CREATE_PROCESS_DEBUG_EVENT
:
1507 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1508 (unsigned) current_event
.dwProcessId
,
1509 (unsigned) current_event
.dwThreadId
,
1510 "CREATE_PROCESS_DEBUG_EVENT"));
1511 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1512 if (++saw_create
!= 1)
1515 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1517 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1519 main_thread_id
= current_event
.dwThreadId
;
1520 /* Add the main thread. */
1521 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1522 current_event
.dwThreadId
),
1523 current_event
.u
.CreateProcessInfo
.hThread
,
1524 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1525 retval
= current_event
.dwThreadId
;
1528 case EXIT_PROCESS_DEBUG_EVENT
:
1529 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1530 (unsigned) current_event
.dwProcessId
,
1531 (unsigned) current_event
.dwThreadId
,
1532 "EXIT_PROCESS_DEBUG_EVENT"));
1533 if (!windows_initialization_done
)
1535 target_terminal_ours ();
1536 target_mourn_inferior ();
1537 error (_("During startup program exited with code 0x%x."),
1538 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1540 else if (saw_create
== 1)
1542 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1543 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1544 retval
= main_thread_id
;
1548 case LOAD_DLL_DEBUG_EVENT
:
1549 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1550 (unsigned) current_event
.dwProcessId
,
1551 (unsigned) current_event
.dwThreadId
,
1552 "LOAD_DLL_DEBUG_EVENT"));
1553 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1554 if (saw_create
!= 1)
1556 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1557 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1558 ourstatus
->value
.integer
= 0;
1559 retval
= main_thread_id
;
1562 case UNLOAD_DLL_DEBUG_EVENT
:
1563 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1564 (unsigned) current_event
.dwProcessId
,
1565 (unsigned) current_event
.dwThreadId
,
1566 "UNLOAD_DLL_DEBUG_EVENT"));
1567 if (saw_create
!= 1)
1569 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1570 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1571 ourstatus
->value
.integer
= 0;
1572 retval
= main_thread_id
;
1575 case EXCEPTION_DEBUG_EVENT
:
1576 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1577 (unsigned) current_event
.dwProcessId
,
1578 (unsigned) current_event
.dwThreadId
,
1579 "EXCEPTION_DEBUG_EVENT"));
1580 if (saw_create
!= 1)
1582 switch (handle_exception (ourstatus
))
1585 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1588 retval
= current_event
.dwThreadId
;
1592 continue_status
= -1;
1597 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1598 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1599 (unsigned) current_event
.dwProcessId
,
1600 (unsigned) current_event
.dwThreadId
,
1601 "OUTPUT_DEBUG_STRING_EVENT"));
1602 if (saw_create
!= 1)
1604 retval
= handle_output_debug_string (ourstatus
);
1608 if (saw_create
!= 1)
1610 printf_unfiltered ("gdb: kernel event for pid=%u tid=%x\n",
1611 (unsigned) current_event
.dwProcessId
,
1612 (unsigned) current_event
.dwThreadId
);
1613 printf_unfiltered (" unknown event code %u\n",
1614 (unsigned) current_event
.dwDebugEventCode
);
1618 if (!retval
|| saw_create
!= 1)
1620 if (continue_status
== -1)
1621 windows_resume (ops
, minus_one_ptid
, 0, 1);
1623 CHECK (windows_continue (continue_status
, -1));
1627 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1629 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1636 /* Wait for interesting events to occur in the target process. */
1638 windows_wait (struct target_ops
*ops
,
1639 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1643 target_terminal_ours ();
1645 /* We loop when we get a non-standard exception rather than return
1646 with a SPURIOUS because resume can try and step or modify things,
1647 which needs a current_thread->h. But some of these exceptions mark
1648 the birth or death of threads, which mean that the current thread
1649 isn't necessarily what you think it is. */
1655 /* If the user presses Ctrl-c while the debugger is waiting
1656 for an event, he expects the debugger to interrupt his program
1657 and to get the prompt back. There are two possible situations:
1659 - The debugger and the program do not share the console, in
1660 which case the Ctrl-c event only reached the debugger.
1661 In that case, the ctrl_c handler will take care of interrupting
1662 the inferior. Note that this case is working starting with
1663 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1666 - The debugger and the program share the same console, in which
1667 case both debugger and inferior will receive the Ctrl-c event.
1668 In that case the ctrl_c handler will ignore the event, as the
1669 Ctrl-c event generated inside the inferior will trigger the
1670 expected debug event.
1672 FIXME: brobecker/2008-05-20: If the inferior receives the
1673 signal first and the delay until GDB receives that signal
1674 is sufficiently long, GDB can sometimes receive the SIGINT
1675 after we have unblocked the CTRL+C handler. This would
1676 lead to the debugger stopping prematurely while handling
1677 the new-thread event that comes with the handling of the SIGINT
1678 inside the inferior, and then stop again immediately when
1679 the user tries to resume the execution in the inferior.
1680 This is a classic race that we should try to fix one day. */
1681 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1682 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1683 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1686 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1691 if (deprecated_ui_loop_hook
!= NULL
)
1692 detach
= deprecated_ui_loop_hook (0);
1695 windows_kill_inferior (ops
);
1701 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1703 extern int stop_after_trap
;
1705 struct inferior
*inf
;
1706 struct thread_info
*tp
;
1708 last_sig
= GDB_SIGNAL_0
;
1710 exception_count
= 0;
1711 open_process_used
= 0;
1712 debug_registers_changed
= 0;
1713 debug_registers_used
= 0;
1714 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1717 cygwin_load_start
= cygwin_load_end
= 0;
1719 current_event
.dwProcessId
= pid
;
1720 memset (¤t_event
, 0, sizeof (current_event
));
1722 disable_breakpoints_in_shlibs ();
1723 windows_clear_solib ();
1724 clear_proceed_status ();
1725 init_wait_for_inferior ();
1727 inf
= current_inferior ();
1728 inferior_appeared (inf
, pid
);
1729 inf
->attach_flag
= attaching
;
1731 /* Make the new process the current inferior, so terminal handling
1732 can rely on it. When attaching, we don't know about any thread
1733 id here, but that's OK --- nothing should be referencing the
1734 current thread until we report an event out of windows_wait. */
1735 inferior_ptid
= pid_to_ptid (pid
);
1737 terminal_init_inferior_with_pgrp (pid
);
1738 target_terminal_inferior ();
1740 windows_initialization_done
= 0;
1741 inf
->control
.stop_soon
= STOP_QUIETLY
;
1744 stop_after_trap
= 1;
1745 wait_for_inferior ();
1746 tp
= inferior_thread ();
1747 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1748 resume (0, tp
->suspend
.stop_signal
);
1753 windows_initialization_done
= 1;
1754 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1755 stop_after_trap
= 0;
1759 /* Try to set or remove a user privilege to the current process. Return -1
1760 if that fails, the previous setting of that privilege otherwise.
1762 This code is copied from the Cygwin source code and rearranged to allow
1763 dynamically loading of the needed symbols from advapi32 which is only
1764 available on NT/2K/XP. */
1766 set_process_privilege (const char *privilege
, BOOL enable
)
1768 HANDLE token_hdl
= NULL
;
1770 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1774 if (!OpenProcessToken (GetCurrentProcess (),
1775 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1779 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1782 new_priv
.PrivilegeCount
= 1;
1783 new_priv
.Privileges
[0].Luid
= restore_priv
;
1784 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1786 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1787 sizeof orig_priv
, &orig_priv
, &size
))
1790 /* Disabled, otherwise every `attach' in an unprivileged user session
1791 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1792 windows_attach(). */
1793 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1794 be enabled. GetLastError () returns an correct error code, though. */
1795 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1799 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1803 CloseHandle (token_hdl
);
1808 /* Attach to process PID, then initialize for debugging it. */
1810 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1815 pid
= parse_pid_to_attach (args
);
1817 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1819 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1820 printf_unfiltered ("This can cause attach to "
1821 "fail on Windows NT/2K/XP\n");
1824 windows_init_thread_list ();
1825 ok
= DebugActiveProcess (pid
);
1831 /* Try fall back to Cygwin pid. */
1832 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1835 ok
= DebugActiveProcess (pid
);
1840 error (_("Can't attach to process."));
1842 DebugSetProcessKillOnExit (FALSE
);
1846 char *exec_file
= (char *) get_exec_file (0);
1849 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1850 target_pid_to_str (pid_to_ptid (pid
)));
1852 printf_unfiltered ("Attaching to %s\n",
1853 target_pid_to_str (pid_to_ptid (pid
)));
1855 gdb_flush (gdb_stdout
);
1858 do_initial_windows_stuff (ops
, pid
, 1);
1859 target_terminal_ours ();
1863 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1868 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1870 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1872 error (_("Can't detach process %u (error %u)"),
1873 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1876 DebugSetProcessKillOnExit (FALSE
);
1878 if (detached
&& from_tty
)
1880 char *exec_file
= get_exec_file (0);
1883 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1884 (unsigned) current_event
.dwProcessId
);
1885 gdb_flush (gdb_stdout
);
1888 i386_cleanup_dregs ();
1889 inferior_ptid
= null_ptid
;
1890 detach_inferior (current_event
.dwProcessId
);
1892 unpush_target (ops
);
1896 windows_pid_to_exec_file (int pid
)
1898 static char path
[__PMAX
];
1900 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1902 char procexe
[sizeof ("/proc/4294967295/exe")];
1904 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1905 nchars
= readlink (procexe
, path
, sizeof(path
));
1906 if (nchars
> 0 && nchars
< sizeof (path
))
1908 path
[nchars
] = '\0'; /* Got it */
1913 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1914 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1915 if (!get_module_name (0, path
))
1921 /* Print status information about what we're accessing. */
1924 windows_files_info (struct target_ops
*ignore
)
1926 struct inferior
*inf
= current_inferior ();
1928 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1929 inf
->attach_flag
? "attached" : "child",
1930 target_pid_to_str (inferior_ptid
));
1934 windows_open (char *arg
, int from_tty
)
1936 error (_("Use the \"run\" command to start a Unix child process."));
1939 /* Modify CreateProcess parameters for use of a new separate console.
1941 *FLAGS: DWORD parameter for general process creation flags.
1942 *SI: STARTUPINFO structure, for which the console window size and
1943 console buffer size is filled in if GDB is running in a console.
1944 to create the new console.
1945 The size of the used font is not available on all versions of
1946 Windows OS. Furthermore, the current font might not be the default
1947 font, but this is still better than before.
1948 If the windows and buffer sizes are computed,
1949 SI->DWFLAGS is changed so that this information is used
1950 by CreateProcess function. */
1953 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1955 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1956 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1958 if (hconsole
!= INVALID_HANDLE_VALUE
)
1960 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1962 CONSOLE_FONT_INFO cfi
;
1964 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1965 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1966 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1967 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1968 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1970 si
->dwXSize
*= font_size
.X
;
1974 si
->dwYSize
*= font_size
.Y
;
1977 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1978 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1979 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1981 *flags
|= CREATE_NEW_CONSOLE
;
1985 /* Function called by qsort to sort environment strings. */
1988 envvar_cmp (const void *a
, const void *b
)
1990 const char **p
= (const char **) a
;
1991 const char **q
= (const char **) b
;
1992 return strcasecmp (*p
, *q
);
1998 clear_win32_environment (char **env
)
2002 wchar_t *copy
= NULL
, *equalpos
;
2004 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2006 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2007 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2008 mbstowcs (copy
, env
[i
], len
);
2009 equalpos
= wcschr (copy
, L
'=');
2012 SetEnvironmentVariableW (copy
, NULL
);
2018 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2019 EXEC_FILE is the file to run.
2020 ALLARGS is a string containing the arguments to the program.
2021 ENV is the environment vector to pass. Errors reported with error(). */
2024 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2025 char *allargs
, char **in_env
, int from_tty
)
2029 cygwin_buf_t real_path
[__PMAX
];
2030 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2032 cygwin_buf_t
*toexec
;
2033 cygwin_buf_t
*cygallargs
;
2035 char **old_env
= NULL
;
2039 int ostdin
, ostdout
, ostderr
;
2041 char real_path
[__PMAX
];
2042 char shell
[__PMAX
]; /* Path to shell */
2054 PROCESS_INFORMATION pi
;
2057 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2060 error (_("No executable specified, use `target exec'."));
2062 memset (&si
, 0, sizeof (si
));
2063 si
.cb
= sizeof (si
);
2066 flags
|= CREATE_NEW_PROCESS_GROUP
;
2069 windows_set_console_info (&si
, &flags
);
2074 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2075 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2076 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2077 error (_("Error starting executable: %d"), errno
);
2080 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2081 if (len
== (size_t) -1)
2082 error (_("Error starting executable: %d"), errno
);
2083 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2084 mbstowcs (cygallargs
, allargs
, len
);
2086 cygallargs
= allargs
;
2091 sh
= getenv ("SHELL");
2094 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2095 error (_("Error starting executable via shell: %d"), errno
);
2097 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2098 + mbstowcs (NULL
, allargs
, 0) + 2;
2099 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2100 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2102 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2103 + strlen (allargs
) + 2);
2104 cygallargs
= (char *) alloca (len
);
2105 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2108 flags
|= DEBUG_PROCESS
;
2112 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2113 * sizeof (wchar_t));
2114 wcscpy (args
, toexec
);
2115 wcscat (args
, L
" ");
2116 wcscat (args
, cygallargs
);
2118 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2119 strcpy (args
, toexec
);
2121 strcat (args
, cygallargs
);
2124 #ifdef CW_CVT_ENV_TO_WINENV
2125 /* First try to create a direct Win32 copy of the POSIX environment. */
2126 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2127 if (w32_env
!= (PWCHAR
) -1)
2128 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2130 /* If that fails, fall back to old method tweaking GDB's environment. */
2133 /* Reset all Win32 environment variables to avoid leftover on next run. */
2134 clear_win32_environment (environ
);
2135 /* Prepare the environment vars for CreateProcess. */
2138 cygwin_internal (CW_SYNC_WINENV
);
2142 if (!inferior_io_terminal
)
2143 tty
= ostdin
= ostdout
= ostderr
= -1;
2146 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2149 print_sys_errmsg (inferior_io_terminal
, errno
);
2150 ostdin
= ostdout
= ostderr
= -1;
2163 windows_init_thread_list ();
2164 ret
= CreateProcess (0,
2165 args
, /* command line */
2166 NULL
, /* Security */
2168 TRUE
, /* inherit handles */
2169 flags
, /* start flags */
2170 w32_env
, /* environment */
2171 NULL
, /* current directory */
2175 /* Just free the Win32 environment, if it could be created. */
2179 /* Reset all environment variables to avoid leftover on next run. */
2180 clear_win32_environment (in_env
);
2181 /* Restore normal GDB environment variables. */
2183 cygwin_internal (CW_SYNC_WINENV
);
2198 /* Build the command line, a space-separated list of tokens where
2199 the first token is the name of the module to be executed.
2200 To avoid ambiguities introduced by spaces in the module name,
2202 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2203 args
= alloca (args_len
);
2204 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2206 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2208 if (!inferior_io_terminal
)
2209 tty
= INVALID_HANDLE_VALUE
;
2212 SECURITY_ATTRIBUTES sa
;
2213 sa
.nLength
= sizeof(sa
);
2214 sa
.lpSecurityDescriptor
= 0;
2215 sa
.bInheritHandle
= TRUE
;
2216 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2217 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2218 if (tty
== INVALID_HANDLE_VALUE
)
2219 warning (_("Warning: Failed to open TTY %s, error %#x."),
2220 inferior_io_terminal
, (unsigned) GetLastError ());
2224 si
.hStdOutput
= tty
;
2226 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2230 /* CreateProcess takes the environment list as a null terminated set of
2231 strings (i.e. two nulls terminate the list). */
2233 /* Get total size for env strings. */
2234 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2235 envlen
+= strlen (in_env
[i
]) + 1;
2237 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2238 env
= (char **) alloca (envsize
);
2239 memcpy (env
, in_env
, envsize
);
2240 /* Windows programs expect the environment block to be sorted. */
2241 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2243 w32env
= alloca (envlen
+ 1);
2245 /* Copy env strings into new buffer. */
2246 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2248 strcpy (temp
, env
[i
]);
2249 temp
+= strlen (temp
) + 1;
2252 /* Final nil string to terminate new env. */
2255 windows_init_thread_list ();
2256 ret
= CreateProcessA (0,
2257 args
, /* command line */
2258 NULL
, /* Security */
2260 TRUE
, /* inherit handles */
2261 flags
, /* start flags */
2262 w32env
, /* environment */
2263 NULL
, /* current directory */
2266 if (tty
!= INVALID_HANDLE_VALUE
)
2271 error (_("Error creating process %s, (error %u)."),
2272 exec_file
, (unsigned) GetLastError ());
2274 CloseHandle (pi
.hThread
);
2275 CloseHandle (pi
.hProcess
);
2277 if (useshell
&& shell
[0] != '\0')
2282 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2284 /* windows_continue (DBG_CONTINUE, -1); */
2288 windows_mourn_inferior (struct target_ops
*ops
)
2290 (void) windows_continue (DBG_CONTINUE
, -1);
2291 i386_cleanup_dregs();
2292 if (open_process_used
)
2294 CHECK (CloseHandle (current_process_handle
));
2295 open_process_used
= 0;
2297 unpush_target (ops
);
2298 generic_mourn_inferior ();
2301 /* Send a SIGINT to the process group. This acts just like the user typed a
2302 ^C on the controlling terminal. */
2305 windows_stop (ptid_t ptid
)
2307 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2308 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2309 registers_changed (); /* refresh register state */
2313 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2314 int write
, struct mem_attrib
*mem
,
2315 struct target_ops
*target
)
2320 DEBUG_MEM (("gdb: write target memory, %d bytes at %s\n",
2321 len
, core_addr_to_string (memaddr
)));
2322 if (!WriteProcessMemory (current_process_handle
,
2323 (LPVOID
) (uintptr_t) memaddr
, our
,
2326 FlushInstructionCache (current_process_handle
,
2327 (LPCVOID
) (uintptr_t) memaddr
, len
);
2331 DEBUG_MEM (("gdb: read target memory, %d bytes at %s\n",
2332 len
, core_addr_to_string (memaddr
)));
2333 if (!ReadProcessMemory (current_process_handle
,
2334 (LPCVOID
) (uintptr_t) memaddr
, our
,
2342 windows_kill_inferior (struct target_ops
*ops
)
2344 CHECK (TerminateProcess (current_process_handle
, 0));
2348 if (!windows_continue (DBG_CONTINUE
, -1))
2350 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2352 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2356 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2360 windows_prepare_to_store (struct regcache
*regcache
)
2362 /* Do nothing, since we can store individual regs. */
2366 windows_can_run (void)
2372 windows_close (void)
2374 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2375 PIDGET (inferior_ptid
)));
2378 /* Convert pid to printable format. */
2380 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2382 static char buf
[80];
2384 if (ptid_get_tid (ptid
) != 0)
2386 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2387 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2391 return normal_pid_to_str (ptid
);
2395 windows_xfer_shared_libraries (struct target_ops
*ops
,
2396 enum target_object object
, const char *annex
,
2397 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2398 ULONGEST offset
, LONGEST len
)
2400 struct obstack obstack
;
2408 obstack_init (&obstack
);
2409 obstack_grow_str (&obstack
, "<library-list>\n");
2410 for (so
= solib_start
.next
; so
; so
= so
->next
)
2411 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2412 (uintptr_t) so
->lm_info
->load_addr
,
2413 target_gdbarch (), &obstack
);
2414 obstack_grow_str0 (&obstack
, "</library-list>\n");
2416 buf
= obstack_finish (&obstack
);
2417 len_avail
= strlen (buf
);
2418 if (offset
>= len_avail
)
2422 if (len
> len_avail
- offset
)
2423 len
= len_avail
- offset
;
2424 memcpy (readbuf
, buf
+ offset
, len
);
2427 obstack_free (&obstack
, NULL
);
2432 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2433 const char *annex
, gdb_byte
*readbuf
,
2434 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2438 case TARGET_OBJECT_MEMORY
:
2440 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2441 len
, 0/*read*/, NULL
, ops
);
2443 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2444 len
, 1/*write*/, NULL
, ops
);
2447 case TARGET_OBJECT_LIBRARIES
:
2448 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2449 writebuf
, offset
, len
);
2452 if (ops
->beneath
!= NULL
)
2453 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2454 readbuf
, writebuf
, offset
, len
);
2459 /* Provide thread local base, i.e. Thread Information Block address.
2460 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2463 windows_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2467 th
= thread_rec (ptid_get_tid (ptid
), 0);
2472 *addr
= th
->thread_local_base
;
2478 windows_get_ada_task_ptid (long lwp
, long thread
)
2480 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2484 init_windows_ops (void)
2486 windows_ops
.to_shortname
= "child";
2487 windows_ops
.to_longname
= "Win32 child process";
2488 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2489 windows_ops
.to_open
= windows_open
;
2490 windows_ops
.to_close
= windows_close
;
2491 windows_ops
.to_attach
= windows_attach
;
2492 windows_ops
.to_attach_no_wait
= 1;
2493 windows_ops
.to_detach
= windows_detach
;
2494 windows_ops
.to_resume
= windows_resume
;
2495 windows_ops
.to_wait
= windows_wait
;
2496 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2497 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2498 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2499 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2500 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2501 windows_ops
.to_files_info
= windows_files_info
;
2502 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2503 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2504 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2505 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2506 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2507 windows_ops
.to_terminal_ours
= terminal_ours
;
2508 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2509 windows_ops
.to_terminal_info
= child_terminal_info
;
2510 windows_ops
.to_kill
= windows_kill_inferior
;
2511 windows_ops
.to_create_inferior
= windows_create_inferior
;
2512 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2513 windows_ops
.to_can_run
= windows_can_run
;
2514 windows_ops
.to_thread_alive
= windows_thread_alive
;
2515 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2516 windows_ops
.to_stop
= windows_stop
;
2517 windows_ops
.to_stratum
= process_stratum
;
2518 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2519 windows_ops
.to_has_memory
= default_child_has_memory
;
2520 windows_ops
.to_has_stack
= default_child_has_stack
;
2521 windows_ops
.to_has_registers
= default_child_has_registers
;
2522 windows_ops
.to_has_execution
= default_child_has_execution
;
2523 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2524 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2525 windows_ops
.to_get_tib_address
= windows_get_tib_address
;
2527 i386_use_watchpoints (&windows_ops
);
2529 i386_dr_low
.set_control
= cygwin_set_dr7
;
2530 i386_dr_low
.set_addr
= cygwin_set_dr
;
2531 i386_dr_low
.get_addr
= cygwin_get_dr
;
2532 i386_dr_low
.get_status
= cygwin_get_dr6
;
2533 i386_dr_low
.get_control
= cygwin_get_dr7
;
2535 /* i386_dr_low.debug_register_length field is set by
2536 calling i386_set_debug_register_length function
2537 in processor windows specific native file. */
2539 windows_ops
.to_magic
= OPS_MAGIC
;
2543 set_windows_aliases (char *argv0
)
2545 add_info_alias ("dll", "sharedlibrary", 1);
2548 /* -Wmissing-prototypes */
2549 extern initialize_file_ftype _initialize_windows_nat
;
2552 _initialize_windows_nat (void)
2554 struct cmd_list_element
*c
;
2556 init_windows_ops ();
2559 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2562 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2563 _("Load dll library symbols from FILE."));
2564 set_cmd_completer (c
, filename_completer
);
2566 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2568 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2570 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2573 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2574 Set use of shell to start subprocess."), _("\
2575 Show use of shell to start subprocess."), NULL
,
2577 NULL
, /* FIXME: i18n: */
2578 &setlist
, &showlist
);
2580 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2581 &cygwin_exceptions
, _("\
2582 Break when an exception is detected in the Cygwin DLL itself."), _("\
2583 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2585 NULL
, /* FIXME: i18n: */
2586 &setlist
, &showlist
);
2589 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2590 Set creation of new console when creating child process."), _("\
2591 Show creation of new console when creating child process."), NULL
,
2593 NULL
, /* FIXME: i18n: */
2594 &setlist
, &showlist
);
2596 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2597 Set creation of new group when creating child process."), _("\
2598 Show creation of new group when creating child process."), NULL
,
2600 NULL
, /* FIXME: i18n: */
2601 &setlist
, &showlist
);
2603 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2604 Set whether to display execution in child process."), _("\
2605 Show whether to display execution in child process."), NULL
,
2607 NULL
, /* FIXME: i18n: */
2608 &setlist
, &showlist
);
2610 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2611 Set whether to display kernel events in child process."), _("\
2612 Show whether to display kernel events in child process."), NULL
,
2614 NULL
, /* FIXME: i18n: */
2615 &setlist
, &showlist
);
2617 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2618 Set whether to display memory accesses in child process."), _("\
2619 Show whether to display memory accesses in child process."), NULL
,
2621 NULL
, /* FIXME: i18n: */
2622 &setlist
, &showlist
);
2624 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2625 &debug_exceptions
, _("\
2626 Set whether to display kernel exceptions in child process."), _("\
2627 Show whether to display kernel exceptions in child process."), NULL
,
2629 NULL
, /* FIXME: i18n: */
2630 &setlist
, &showlist
);
2632 init_w32_command_list ();
2634 add_cmd ("selector", class_info
, display_selectors
,
2635 _("Display selectors infos."),
2637 add_target (&windows_ops
);
2638 deprecated_init_ui_hook
= set_windows_aliases
;
2641 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2643 /* Pass the address ADDR to the inferior in the I'th debug register.
2644 Here we just store the address in dr array, the registers will be
2645 actually set up when windows_continue is called. */
2647 cygwin_set_dr (int i
, CORE_ADDR addr
)
2650 internal_error (__FILE__
, __LINE__
,
2651 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2653 debug_registers_changed
= 1;
2654 debug_registers_used
= 1;
2657 /* Pass the value VAL to the inferior in the DR7 debug control
2658 register. Here we just store the address in D_REGS, the watchpoint
2659 will be actually set up in windows_wait. */
2661 cygwin_set_dr7 (unsigned long val
)
2663 dr
[7] = (CORE_ADDR
) val
;
2664 debug_registers_changed
= 1;
2665 debug_registers_used
= 1;
2668 /* Get the value of debug register I from the inferior. */
2671 cygwin_get_dr (int i
)
2676 /* Get the value of the DR6 debug status register from the inferior.
2677 Here we just return the value stored in dr[6]
2678 by the last call to thread_rec for current_event.dwThreadId id. */
2679 static unsigned long
2680 cygwin_get_dr6 (void)
2682 return (unsigned long) dr
[6];
2685 /* Get the value of the DR7 debug status register from the inferior.
2686 Here we just return the value stored in dr[7] by the last call to
2687 thread_rec for current_event.dwThreadId id. */
2689 static unsigned long
2690 cygwin_get_dr7 (void)
2692 return (unsigned long) dr
[7];
2695 /* Determine if the thread referenced by "ptid" is alive
2696 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2697 it means that the thread has died. Otherwise it is assumed to be alive. */
2699 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2703 gdb_assert (ptid_get_tid (ptid
) != 0);
2704 tid
= ptid_get_tid (ptid
);
2706 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2710 /* -Wmissing-prototypes */
2711 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2714 _initialize_check_for_gdb_ini (void)
2717 if (inhibit_gdbinit
)
2720 homedir
= getenv ("HOME");
2724 char *oldini
= (char *) alloca (strlen (homedir
) +
2725 sizeof ("/gdb.ini"));
2726 strcpy (oldini
, homedir
);
2727 p
= strchr (oldini
, '\0');
2728 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2730 strcpy (p
, "gdb.ini");
2731 if (access (oldini
, 0) == 0)
2733 int len
= strlen (oldini
);
2734 char *newini
= alloca (len
+ 1);
2736 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2737 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2738 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2743 /* Define dummy functions which always return error for the rare cases where
2744 these functions could not be found. */
2746 bad_DebugActiveProcessStop (DWORD w
)
2751 bad_DebugBreakProcess (HANDLE w
)
2756 bad_DebugSetProcessKillOnExit (BOOL w
)
2761 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2768 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2774 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2781 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2787 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2793 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2799 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2807 /* -Wmissing-prototypes */
2808 extern initialize_file_ftype _initialize_loadable
;
2810 /* Load any functions which may not be available in ancient versions
2814 _initialize_loadable (void)
2818 hm
= LoadLibrary ("kernel32.dll");
2821 DebugActiveProcessStop
= (void *)
2822 GetProcAddress (hm
, "DebugActiveProcessStop");
2823 DebugBreakProcess
= (void *)
2824 GetProcAddress (hm
, "DebugBreakProcess");
2825 DebugSetProcessKillOnExit
= (void *)
2826 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2827 GetConsoleFontSize
= (void *)
2828 GetProcAddress (hm
, "GetConsoleFontSize");
2829 GetCurrentConsoleFont
= (void *)
2830 GetProcAddress (hm
, "GetCurrentConsoleFont");
2833 /* Set variables to dummy versions of these processes if the function
2834 wasn't found in kernel32.dll. */
2835 if (!DebugBreakProcess
)
2836 DebugBreakProcess
= bad_DebugBreakProcess
;
2837 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2839 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2840 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2842 if (!GetConsoleFontSize
)
2843 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2844 if (!GetCurrentConsoleFont
)
2845 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2847 /* Load optional functions used for retrieving filename information
2848 associated with the currently debugged process or its dlls. */
2849 hm
= LoadLibrary ("psapi.dll");
2852 EnumProcessModules
= (void *)
2853 GetProcAddress (hm
, "EnumProcessModules");
2854 GetModuleInformation
= (void *)
2855 GetProcAddress (hm
, "GetModuleInformation");
2856 GetModuleFileNameEx
= (void *)
2857 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2860 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2862 /* Set variables to dummy versions of these processes if the function
2863 wasn't found in psapi.dll. */
2864 EnumProcessModules
= bad_EnumProcessModules
;
2865 GetModuleInformation
= bad_GetModuleInformation
;
2866 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2867 /* This will probably fail on Windows 9x/Me. Let the user know
2868 that we're missing some functionality. */
2870 cannot automatically find executable file or library to read symbols.\n\
2871 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2874 hm
= LoadLibrary ("advapi32.dll");
2877 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2878 LookupPrivilegeValueA
= (void *)
2879 GetProcAddress (hm
, "LookupPrivilegeValueA");
2880 AdjustTokenPrivileges
= (void *)
2881 GetProcAddress (hm
, "AdjustTokenPrivileges");
2882 /* Only need to set one of these since if OpenProcessToken fails nothing
2884 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2885 || !AdjustTokenPrivileges
)
2886 OpenProcessToken
= bad_OpenProcessToken
;