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 %lu\n", file
, line
,
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 %d)"),
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: %lu."), GetLastError ());
580 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
582 error (_("Error converting dll name to POSIX: %d."), errno
);
584 len
= GetModuleFileNameEx (current_process_handle
,
585 DllHandle
[i
], dll_name_ret
, __PMAX
);
587 error (_("Error getting dll name: %u."),
588 (unsigned) GetLastError ());
590 return 1; /* success */
595 dll_name_ret
[0] = '\0';
596 return 0; /* failure */
599 /* Encapsulate the information required in a call to
600 symbol_file_add_args. */
601 struct safe_symbol_file_add_args
605 struct section_addr_info
*addrs
;
608 struct ui_file
*err
, *out
;
612 /* Maintain a linked list of "so" information. */
618 static struct so_list solib_start
, *solib_end
;
620 /* Call symbol_file_add with stderr redirected. We don't care if there
623 safe_symbol_file_add_stub (void *argv
)
625 #define p ((struct safe_symbol_file_add_args *) argv)
626 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
627 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
628 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
633 /* Restore gdb's stderr after calling symbol_file_add. */
635 safe_symbol_file_add_cleanup (void *p
)
637 #define sp ((struct safe_symbol_file_add_args *)p)
638 gdb_flush (gdb_stderr
);
639 gdb_flush (gdb_stdout
);
640 ui_file_delete (gdb_stderr
);
641 ui_file_delete (gdb_stdout
);
642 gdb_stderr
= sp
->err
;
643 gdb_stdout
= sp
->out
;
647 /* symbol_file_add wrapper that prevents errors from being displayed. */
648 static struct objfile
*
649 safe_symbol_file_add (char *name
, int from_tty
,
650 struct section_addr_info
*addrs
,
651 int mainline
, int flags
)
653 struct safe_symbol_file_add_args p
;
654 struct cleanup
*cleanup
;
656 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
660 gdb_flush (gdb_stderr
);
661 gdb_flush (gdb_stdout
);
662 gdb_stderr
= ui_file_new ();
663 gdb_stdout
= ui_file_new ();
665 p
.from_tty
= from_tty
;
667 p
.mainline
= mainline
;
669 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
671 do_cleanups (cleanup
);
675 static struct so_list
*
676 windows_make_so (const char *name
, LPVOID load_addr
)
683 WIN32_FIND_DATA w32_fd
;
684 HANDLE h
= FindFirstFile(name
, &w32_fd
);
686 if (h
== INVALID_HANDLE_VALUE
)
692 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
694 p
= strrchr (buf
, '\\');
697 SetCurrentDirectory (buf
);
698 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
699 SetCurrentDirectory (cwd
);
702 if (strcasecmp (buf
, "ntdll.dll") == 0)
704 GetSystemDirectory (buf
, sizeof (buf
));
705 strcat (buf
, "\\ntdll.dll");
708 cygwin_buf_t buf
[__PMAX
];
711 if (access (name
, F_OK
) != 0)
713 if (strcasecmp (name
, "ntdll.dll") == 0)
716 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
717 wcscat (buf
, L
"\\ntdll.dll");
721 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
722 strcat (buf
, "\\ntdll.dll");
727 so
= XZALLOC (struct so_list
);
728 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
729 so
->lm_info
->load_addr
= load_addr
;
730 strcpy (so
->so_original_name
, name
);
732 strcpy (so
->so_name
, buf
);
735 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
736 SO_NAME_MAX_PATH_SIZE
);
739 char *rname
= realpath (name
, NULL
);
740 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
742 strcpy (so
->so_name
, rname
);
746 error (_("dll path too long"));
748 /* Record cygwin1.dll .text start/end. */
749 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
750 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
753 asection
*text
= NULL
;
756 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
761 if (bfd_check_format (abfd
, bfd_object
))
762 text
= bfd_get_section_by_name (abfd
, ".text");
766 gdb_bfd_unref (abfd
);
770 /* The symbols in a dll are offset by 0x1000, which is the
771 offset from 0 of the first byte in an image - because of the
772 file header and the section alignment. */
773 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
775 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
777 gdb_bfd_unref (abfd
);
785 get_image_name (HANDLE h
, void *address
, int unicode
)
788 static char buf
[__PMAX
];
790 static char buf
[(2 * __PMAX
) + 1];
792 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
798 /* Attempt to read the name of the dll that was detected.
799 This is documented to work only when actively debugging
800 a program. It will not work for attached processes. */
804 /* See if we could read the address of a string, and that the
805 address isn't null. */
806 if (!ReadProcessMemory (h
, address
, &address_ptr
,
807 sizeof (address_ptr
), &done
)
808 || done
!= sizeof (address_ptr
) || !address_ptr
)
811 /* Find the length of the string. */
812 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
813 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
817 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
820 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
821 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
824 wcstombs (buf
, unicode_address
, __PMAX
);
826 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
834 /* Wait for child to do something. Return pid of child, or -1 in case
835 of error; store status through argument pointer OURSTATUS. */
837 handle_load_dll (void *dummy
)
839 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
840 char dll_buf
[__PMAX
];
841 char *dll_name
= NULL
;
843 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
845 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
846 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
850 if (*dll_name
== '\0')
851 dll_name
= get_image_name (current_process_handle
,
852 event
->lpImageName
, event
->fUnicode
);
856 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
857 solib_end
= solib_end
->next
;
859 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
860 host_address_to_string (solib_end
->lm_info
->load_addr
)));
866 windows_free_so (struct so_list
*so
)
874 handle_unload_dll (void *dummy
)
876 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
879 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
880 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
882 struct so_list
*sodel
= so
->next
;
883 so
->next
= sodel
->next
;
886 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
888 windows_free_so (sodel
);
889 solib_add (NULL
, 0, NULL
, auto_solib_add
);
893 /* We did not find any DLL that was previously loaded at this address,
894 so register a complaint. We do not report an error, because we have
895 observed that this may be happening under some circumstances. For
896 instance, running 32bit applications on x64 Windows causes us to receive
897 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
898 events are apparently caused by the WOW layer, the interface between
899 32bit and 64bit worlds). */
900 complaint (&symfile_complaints
, _("dll starting at %s not found."),
901 host_address_to_string (lpBaseOfDll
));
906 /* Clear list of loaded DLLs. */
908 windows_clear_solib (void)
910 solib_start
.next
= NULL
;
911 solib_end
= &solib_start
;
914 /* Load DLL symbol info. */
916 dll_symbol_command (char *args
, int from_tty
)
922 error (_("dll-symbols requires a file name"));
925 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
927 char *newargs
= (char *) alloca (n
+ 4 + 1);
928 strcpy (newargs
, args
);
929 strcat (newargs
, ".dll");
933 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
936 /* Handle DEBUG_STRING output from child process.
937 Cygwin prepends its messages with a "cygwin:". Interpret this as
938 a Cygwin signal. Otherwise just print the string as a warning. */
940 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
945 if (!target_read_string
946 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
950 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
951 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
954 if (strncmp (s
, "cYg", 3) != 0)
958 #ifdef __COPY_CONTEXT_SIZE
961 /* Got a cygwin signal marker. A cygwin signal is followed by
962 the signal number itself and then optionally followed by the
963 thread id and address to saved context within the DLL. If
964 these are supplied, then the given thread is assumed to have
965 issued the signal and the context from the thread is assumed
966 to be stored at the given address in the inferior. Tell gdb
967 to treat this like a real signal. */
969 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
970 int gotasig
= gdb_signal_from_host (sig
);
971 ourstatus
->value
.sig
= gotasig
;
976 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
977 retval
= strtoul (p
, &p
, 0);
979 retval
= main_thread_id
;
980 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
981 && ReadProcessMemory (current_process_handle
, x
,
983 __COPY_CONTEXT_SIZE
, &n
)
984 && n
== __COPY_CONTEXT_SIZE
)
985 have_saved_context
= 1;
986 current_event
.dwThreadId
= retval
;
997 display_selector (HANDLE thread
, DWORD sel
)
1000 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1003 printf_filtered ("0x%03lx: ", sel
);
1004 if (!info
.HighWord
.Bits
.Pres
)
1006 puts_filtered ("Segment not present\n");
1009 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1010 (info
.HighWord
.Bits
.BaseMid
<< 16)
1012 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1013 if (info
.HighWord
.Bits
.Granularity
)
1014 limit
= (limit
<< 12) | 0xfff;
1015 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1016 if (info
.HighWord
.Bits
.Default_Big
)
1017 puts_filtered(" 32-bit ");
1019 puts_filtered(" 16-bit ");
1020 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1023 puts_filtered ("Data (Read-Only, Exp-up");
1026 puts_filtered ("Data (Read/Write, Exp-up");
1029 puts_filtered ("Unused segment (");
1032 puts_filtered ("Data (Read/Write, Exp-down");
1035 puts_filtered ("Code (Exec-Only, N.Conf");
1038 puts_filtered ("Code (Exec/Read, N.Conf");
1041 puts_filtered ("Code (Exec-Only, Conf");
1044 puts_filtered ("Code (Exec/Read, Conf");
1047 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1049 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1050 puts_filtered(", N.Acc");
1051 puts_filtered (")\n");
1052 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1053 puts_filtered("System selector ");
1054 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1055 if (info
.HighWord
.Bits
.Granularity
)
1056 puts_filtered ("Page granular.\n");
1058 puts_filtered ("Byte granular.\n");
1063 DWORD err
= GetLastError ();
1064 if (err
== ERROR_NOT_SUPPORTED
)
1065 printf_filtered ("Function not supported\n");
1067 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
1073 display_selectors (char * args
, int from_tty
)
1075 if (!current_thread
)
1077 puts_filtered ("Impossible to display selectors now.\n");
1083 puts_filtered ("Selector $cs\n");
1084 display_selector (current_thread
->h
,
1085 current_thread
->context
.SegCs
);
1086 puts_filtered ("Selector $ds\n");
1087 display_selector (current_thread
->h
,
1088 current_thread
->context
.SegDs
);
1089 puts_filtered ("Selector $es\n");
1090 display_selector (current_thread
->h
,
1091 current_thread
->context
.SegEs
);
1092 puts_filtered ("Selector $ss\n");
1093 display_selector (current_thread
->h
,
1094 current_thread
->context
.SegSs
);
1095 puts_filtered ("Selector $fs\n");
1096 display_selector (current_thread
->h
,
1097 current_thread
->context
.SegFs
);
1098 puts_filtered ("Selector $gs\n");
1099 display_selector (current_thread
->h
,
1100 current_thread
->context
.SegGs
);
1105 sel
= parse_and_eval_long (args
);
1106 printf_filtered ("Selector \"%s\"\n",args
);
1107 display_selector (current_thread
->h
, sel
);
1111 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1112 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1113 host_address_to_string (\
1114 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1117 handle_exception (struct target_waitstatus
*ourstatus
)
1120 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1122 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1124 /* Record the context of the current thread. */
1125 th
= thread_rec (current_event
.dwThreadId
, -1);
1129 case EXCEPTION_ACCESS_VIOLATION
:
1130 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1131 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1134 /* See if the access violation happened within the cygwin DLL
1135 itself. Cygwin uses a kind of exception handling to deal
1136 with passed-in invalid addresses. gdb should not treat
1137 these as real SEGVs since they will be silently handled by
1138 cygwin. A real SEGV will (theoretically) be caught by
1139 cygwin later in the process and will be sent as a
1140 cygwin-specific-signal. So, ignore SEGVs if they show up
1141 within the text segment of the DLL itself. */
1143 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1144 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1146 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1147 && addr
< cygwin_load_end
))
1148 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1149 && strncmp (fn
, "KERNEL32!IsBad",
1150 strlen ("KERNEL32!IsBad")) == 0))
1155 case STATUS_STACK_OVERFLOW
:
1156 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1157 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1159 case STATUS_FLOAT_DENORMAL_OPERAND
:
1160 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1161 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1163 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1164 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1165 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1167 case STATUS_FLOAT_INEXACT_RESULT
:
1168 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1169 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1171 case STATUS_FLOAT_INVALID_OPERATION
:
1172 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1173 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1175 case STATUS_FLOAT_OVERFLOW
:
1176 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1177 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1179 case STATUS_FLOAT_STACK_CHECK
:
1180 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1181 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1183 case STATUS_FLOAT_UNDERFLOW
:
1184 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1185 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1187 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1188 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1189 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1191 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1192 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1193 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1195 case STATUS_INTEGER_OVERFLOW
:
1196 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1197 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1199 case EXCEPTION_BREAKPOINT
:
1200 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1201 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1204 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1205 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1207 case DBG_CONTROL_BREAK
:
1208 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1209 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1211 case EXCEPTION_SINGLE_STEP
:
1212 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1213 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1215 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1216 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1217 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1219 case EXCEPTION_PRIV_INSTRUCTION
:
1220 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1221 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1223 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1224 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1225 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1228 /* Treat unhandled first chance exceptions specially. */
1229 if (current_event
.u
.Exception
.dwFirstChance
)
1231 printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
1232 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1233 host_address_to_string (
1234 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1235 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1239 last_sig
= ourstatus
->value
.sig
;
1243 /* Resume all artificially suspended threads if we are continuing
1246 windows_continue (DWORD continue_status
, int id
)
1252 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%lx, %s);\n",
1253 current_event
.dwProcessId
, current_event
.dwThreadId
,
1254 continue_status
== DBG_CONTINUE
?
1255 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1257 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1258 if ((id
== -1 || id
== (int) th
->id
)
1261 if (debug_registers_changed
)
1263 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1264 th
->context
.Dr0
= dr
[0];
1265 th
->context
.Dr1
= dr
[1];
1266 th
->context
.Dr2
= dr
[2];
1267 th
->context
.Dr3
= dr
[3];
1268 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1269 th
->context
.Dr7
= dr
[7];
1271 if (th
->context
.ContextFlags
)
1273 CHECK (SetThreadContext (th
->h
, &th
->context
));
1274 th
->context
.ContextFlags
= 0;
1276 if (th
->suspended
> 0)
1277 (void) ResumeThread (th
->h
);
1281 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1282 current_event
.dwThreadId
,
1285 debug_registers_changed
= 0;
1289 /* Called in pathological case where Windows fails to send a
1290 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1292 fake_create_process (void)
1294 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1295 current_event
.dwProcessId
);
1296 if (current_process_handle
!= NULL
)
1297 open_process_used
= 1;
1300 error (_("OpenProcess call failed, GetLastError = %lud"),
1302 /* We can not debug anything in that case. */
1304 main_thread_id
= current_event
.dwThreadId
;
1305 current_thread
= windows_add_thread (
1306 ptid_build (current_event
.dwProcessId
, 0,
1307 current_event
.dwThreadId
),
1308 current_event
.u
.CreateThread
.hThread
,
1309 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1310 return main_thread_id
;
1314 windows_resume (struct target_ops
*ops
,
1315 ptid_t ptid
, int step
, enum gdb_signal sig
)
1318 DWORD continue_status
= DBG_CONTINUE
;
1320 /* A specific PTID means `step only this thread id'. */
1321 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1323 /* If we're continuing all threads, it's the current inferior that
1324 should be handled specially. */
1326 ptid
= inferior_ptid
;
1328 if (sig
!= GDB_SIGNAL_0
)
1330 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1332 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1334 else if (sig
== last_sig
)
1335 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1338 /* This code does not seem to work, because
1339 the kernel does probably not consider changes in the ExceptionRecord
1340 structure when passing the exception to the inferior.
1341 Note that this seems possible in the exception handler itself. */
1344 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1345 if (xlate
[i
].us
== sig
)
1347 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1349 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1352 if (continue_status
== DBG_CONTINUE
)
1354 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1358 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1362 last_sig
= GDB_SIGNAL_0
;
1364 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1365 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1367 /* Get context for currently selected thread. */
1368 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1373 /* Single step by setting t bit. */
1374 struct regcache
*regcache
= get_current_regcache ();
1375 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1376 windows_fetch_inferior_registers (ops
, regcache
,
1377 gdbarch_ps_regnum (gdbarch
));
1378 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1381 if (th
->context
.ContextFlags
)
1383 if (debug_registers_changed
)
1385 th
->context
.Dr0
= dr
[0];
1386 th
->context
.Dr1
= dr
[1];
1387 th
->context
.Dr2
= dr
[2];
1388 th
->context
.Dr3
= dr
[3];
1389 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1390 th
->context
.Dr7
= dr
[7];
1392 CHECK (SetThreadContext (th
->h
, &th
->context
));
1393 th
->context
.ContextFlags
= 0;
1397 /* Allow continuing with the same signal that interrupted us.
1398 Otherwise complain. */
1401 windows_continue (continue_status
, -1);
1403 windows_continue (continue_status
, ptid_get_tid (ptid
));
1406 /* Ctrl-C handler used when the inferior is not run in the same console. The
1407 handler is in charge of interrupting the inferior using DebugBreakProcess.
1408 Note that this function is not available prior to Windows XP. In this case
1409 we emit a warning. */
1411 ctrl_c_handler (DWORD event_type
)
1413 const int attach_flag
= current_inferior ()->attach_flag
;
1415 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1416 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1419 /* If the inferior and the debugger share the same console, do nothing as
1420 the inferior has also received the Ctrl-C event. */
1421 if (!new_console
&& !attach_flag
)
1424 if (!DebugBreakProcess (current_process_handle
))
1425 warning (_("Could not interrupt program. "
1426 "Press Ctrl-c in the program console."));
1428 /* Return true to tell that Ctrl-C has been handled. */
1432 /* Get the next event from the child. Return 1 if the event requires
1433 handling by WFI (or whatever). */
1435 get_windows_debug_event (struct target_ops
*ops
,
1436 int pid
, struct target_waitstatus
*ourstatus
)
1439 DWORD continue_status
, event_code
;
1441 static thread_info dummy_thread_info
;
1444 last_sig
= GDB_SIGNAL_0
;
1446 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1450 continue_status
= DBG_CONTINUE
;
1452 event_code
= current_event
.dwDebugEventCode
;
1453 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1455 have_saved_context
= 0;
1459 case CREATE_THREAD_DEBUG_EVENT
:
1460 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1461 (unsigned) current_event
.dwProcessId
,
1462 (unsigned) current_event
.dwThreadId
,
1463 "CREATE_THREAD_DEBUG_EVENT"));
1464 if (saw_create
!= 1)
1466 struct inferior
*inf
;
1467 inf
= find_inferior_pid (current_event
.dwProcessId
);
1468 if (!saw_create
&& inf
->attach_flag
)
1470 /* Kludge around a Windows bug where first event is a create
1471 thread event. Caused when attached process does not have
1473 retval
= fake_create_process ();
1479 /* Record the existence of this thread. */
1480 retval
= current_event
.dwThreadId
;
1481 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1482 current_event
.dwThreadId
),
1483 current_event
.u
.CreateThread
.hThread
,
1484 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1488 case EXIT_THREAD_DEBUG_EVENT
:
1489 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1490 (unsigned) current_event
.dwProcessId
,
1491 (unsigned) current_event
.dwThreadId
,
1492 "EXIT_THREAD_DEBUG_EVENT"));
1494 if (current_event
.dwThreadId
!= main_thread_id
)
1496 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1497 current_event
.dwThreadId
));
1498 th
= &dummy_thread_info
;
1502 case CREATE_PROCESS_DEBUG_EVENT
:
1503 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1504 (unsigned) current_event
.dwProcessId
,
1505 (unsigned) current_event
.dwThreadId
,
1506 "CREATE_PROCESS_DEBUG_EVENT"));
1507 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1508 if (++saw_create
!= 1)
1511 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1513 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1515 main_thread_id
= current_event
.dwThreadId
;
1516 /* Add the main thread. */
1517 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1518 current_event
.dwThreadId
),
1519 current_event
.u
.CreateProcessInfo
.hThread
,
1520 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1521 retval
= current_event
.dwThreadId
;
1524 case EXIT_PROCESS_DEBUG_EVENT
:
1525 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1526 (unsigned) current_event
.dwProcessId
,
1527 (unsigned) current_event
.dwThreadId
,
1528 "EXIT_PROCESS_DEBUG_EVENT"));
1529 if (!windows_initialization_done
)
1531 target_terminal_ours ();
1532 target_mourn_inferior ();
1533 error (_("During startup program exited with code 0x%x."),
1534 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1536 else if (saw_create
== 1)
1538 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1539 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1540 retval
= main_thread_id
;
1544 case LOAD_DLL_DEBUG_EVENT
:
1545 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1546 (unsigned) current_event
.dwProcessId
,
1547 (unsigned) current_event
.dwThreadId
,
1548 "LOAD_DLL_DEBUG_EVENT"));
1549 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1550 if (saw_create
!= 1)
1552 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1553 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1554 ourstatus
->value
.integer
= 0;
1555 retval
= main_thread_id
;
1558 case UNLOAD_DLL_DEBUG_EVENT
:
1559 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1560 (unsigned) current_event
.dwProcessId
,
1561 (unsigned) current_event
.dwThreadId
,
1562 "UNLOAD_DLL_DEBUG_EVENT"));
1563 if (saw_create
!= 1)
1565 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1566 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1567 ourstatus
->value
.integer
= 0;
1568 retval
= main_thread_id
;
1571 case EXCEPTION_DEBUG_EVENT
:
1572 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1573 (unsigned) current_event
.dwProcessId
,
1574 (unsigned) current_event
.dwThreadId
,
1575 "EXCEPTION_DEBUG_EVENT"));
1576 if (saw_create
!= 1)
1578 switch (handle_exception (ourstatus
))
1581 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1584 retval
= current_event
.dwThreadId
;
1588 continue_status
= -1;
1593 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1594 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1595 (unsigned) current_event
.dwProcessId
,
1596 (unsigned) current_event
.dwThreadId
,
1597 "OUTPUT_DEBUG_STRING_EVENT"));
1598 if (saw_create
!= 1)
1600 retval
= handle_output_debug_string (ourstatus
);
1604 if (saw_create
!= 1)
1606 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1607 (DWORD
) current_event
.dwProcessId
,
1608 (DWORD
) current_event
.dwThreadId
);
1609 printf_unfiltered (" unknown event code %ld\n",
1610 current_event
.dwDebugEventCode
);
1614 if (!retval
|| saw_create
!= 1)
1616 if (continue_status
== -1)
1617 windows_resume (ops
, minus_one_ptid
, 0, 1);
1619 CHECK (windows_continue (continue_status
, -1));
1623 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1625 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1632 /* Wait for interesting events to occur in the target process. */
1634 windows_wait (struct target_ops
*ops
,
1635 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1639 target_terminal_ours ();
1641 /* We loop when we get a non-standard exception rather than return
1642 with a SPURIOUS because resume can try and step or modify things,
1643 which needs a current_thread->h. But some of these exceptions mark
1644 the birth or death of threads, which mean that the current thread
1645 isn't necessarily what you think it is. */
1651 /* If the user presses Ctrl-c while the debugger is waiting
1652 for an event, he expects the debugger to interrupt his program
1653 and to get the prompt back. There are two possible situations:
1655 - The debugger and the program do not share the console, in
1656 which case the Ctrl-c event only reached the debugger.
1657 In that case, the ctrl_c handler will take care of interrupting
1658 the inferior. Note that this case is working starting with
1659 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1662 - The debugger and the program share the same console, in which
1663 case both debugger and inferior will receive the Ctrl-c event.
1664 In that case the ctrl_c handler will ignore the event, as the
1665 Ctrl-c event generated inside the inferior will trigger the
1666 expected debug event.
1668 FIXME: brobecker/2008-05-20: If the inferior receives the
1669 signal first and the delay until GDB receives that signal
1670 is sufficiently long, GDB can sometimes receive the SIGINT
1671 after we have unblocked the CTRL+C handler. This would
1672 lead to the debugger stopping prematurely while handling
1673 the new-thread event that comes with the handling of the SIGINT
1674 inside the inferior, and then stop again immediately when
1675 the user tries to resume the execution in the inferior.
1676 This is a classic race that we should try to fix one day. */
1677 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1678 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1679 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1682 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1687 if (deprecated_ui_loop_hook
!= NULL
)
1688 detach
= deprecated_ui_loop_hook (0);
1691 windows_kill_inferior (ops
);
1697 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1699 extern int stop_after_trap
;
1701 struct inferior
*inf
;
1702 struct thread_info
*tp
;
1704 last_sig
= GDB_SIGNAL_0
;
1706 exception_count
= 0;
1707 open_process_used
= 0;
1708 debug_registers_changed
= 0;
1709 debug_registers_used
= 0;
1710 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1713 cygwin_load_start
= cygwin_load_end
= 0;
1715 current_event
.dwProcessId
= pid
;
1716 memset (¤t_event
, 0, sizeof (current_event
));
1718 disable_breakpoints_in_shlibs ();
1719 windows_clear_solib ();
1720 clear_proceed_status ();
1721 init_wait_for_inferior ();
1723 inf
= current_inferior ();
1724 inferior_appeared (inf
, pid
);
1725 inf
->attach_flag
= attaching
;
1727 /* Make the new process the current inferior, so terminal handling
1728 can rely on it. When attaching, we don't know about any thread
1729 id here, but that's OK --- nothing should be referencing the
1730 current thread until we report an event out of windows_wait. */
1731 inferior_ptid
= pid_to_ptid (pid
);
1733 terminal_init_inferior_with_pgrp (pid
);
1734 target_terminal_inferior ();
1736 windows_initialization_done
= 0;
1737 inf
->control
.stop_soon
= STOP_QUIETLY
;
1740 stop_after_trap
= 1;
1741 wait_for_inferior ();
1742 tp
= inferior_thread ();
1743 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1744 resume (0, tp
->suspend
.stop_signal
);
1749 windows_initialization_done
= 1;
1750 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1751 stop_after_trap
= 0;
1755 /* Try to set or remove a user privilege to the current process. Return -1
1756 if that fails, the previous setting of that privilege otherwise.
1758 This code is copied from the Cygwin source code and rearranged to allow
1759 dynamically loading of the needed symbols from advapi32 which is only
1760 available on NT/2K/XP. */
1762 set_process_privilege (const char *privilege
, BOOL enable
)
1764 HANDLE token_hdl
= NULL
;
1766 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1770 if (!OpenProcessToken (GetCurrentProcess (),
1771 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1775 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1778 new_priv
.PrivilegeCount
= 1;
1779 new_priv
.Privileges
[0].Luid
= restore_priv
;
1780 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1782 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1783 sizeof orig_priv
, &orig_priv
, &size
))
1786 /* Disabled, otherwise every `attach' in an unprivileged user session
1787 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1788 windows_attach(). */
1789 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1790 be enabled. GetLastError () returns an correct error code, though. */
1791 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1795 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1799 CloseHandle (token_hdl
);
1804 /* Attach to process PID, then initialize for debugging it. */
1806 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1811 pid
= parse_pid_to_attach (args
);
1813 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1815 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1816 printf_unfiltered ("This can cause attach to "
1817 "fail on Windows NT/2K/XP\n");
1820 windows_init_thread_list ();
1821 ok
= DebugActiveProcess (pid
);
1827 /* Try fall back to Cygwin pid. */
1828 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1831 ok
= DebugActiveProcess (pid
);
1836 error (_("Can't attach to process."));
1838 DebugSetProcessKillOnExit (FALSE
);
1842 char *exec_file
= (char *) get_exec_file (0);
1845 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1846 target_pid_to_str (pid_to_ptid (pid
)));
1848 printf_unfiltered ("Attaching to %s\n",
1849 target_pid_to_str (pid_to_ptid (pid
)));
1851 gdb_flush (gdb_stdout
);
1854 do_initial_windows_stuff (ops
, pid
, 1);
1855 target_terminal_ours ();
1859 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1864 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1866 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1868 error (_("Can't detach process %lu (error %lu)"),
1869 current_event
.dwProcessId
, GetLastError ());
1872 DebugSetProcessKillOnExit (FALSE
);
1874 if (detached
&& from_tty
)
1876 char *exec_file
= get_exec_file (0);
1879 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1880 current_event
.dwProcessId
);
1881 gdb_flush (gdb_stdout
);
1884 inferior_ptid
= null_ptid
;
1885 detach_inferior (current_event
.dwProcessId
);
1887 unpush_target (ops
);
1891 windows_pid_to_exec_file (int pid
)
1893 static char path
[__PMAX
];
1895 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1897 char procexe
[sizeof ("/proc/4294967295/exe")];
1899 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1900 nchars
= readlink (procexe
, path
, sizeof(path
));
1901 if (nchars
> 0 && nchars
< sizeof (path
))
1903 path
[nchars
] = '\0'; /* Got it */
1908 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1909 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1910 if (!get_module_name (0, path
))
1916 /* Print status information about what we're accessing. */
1919 windows_files_info (struct target_ops
*ignore
)
1921 struct inferior
*inf
= current_inferior ();
1923 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1924 inf
->attach_flag
? "attached" : "child",
1925 target_pid_to_str (inferior_ptid
));
1929 windows_open (char *arg
, int from_tty
)
1931 error (_("Use the \"run\" command to start a Unix child process."));
1934 /* Modify CreateProcess parameters for use of a new separate console.
1936 *FLAGS: DWORD parameter for general process creation flags.
1937 *SI: STARTUPINFO structure, for which the console window size and
1938 console buffer size is filled in if GDB is running in a console.
1939 to create the new console.
1940 The size of the used font is not available on all versions of
1941 Windows OS. Furthermore, the current font might not be the default
1942 font, but this is still better than before.
1943 If the windows and buffer sizes are computed,
1944 SI->DWFLAGS is changed so that this information is used
1945 by CreateProcess function. */
1948 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1950 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1951 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1953 if (hconsole
!= INVALID_HANDLE_VALUE
)
1955 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1957 CONSOLE_FONT_INFO cfi
;
1959 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1960 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1961 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1962 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1963 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1965 si
->dwXSize
*= font_size
.X
;
1969 si
->dwYSize
*= font_size
.Y
;
1972 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1973 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1974 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1976 *flags
|= CREATE_NEW_CONSOLE
;
1980 /* Function called by qsort to sort environment strings. */
1983 envvar_cmp (const void *a
, const void *b
)
1985 const char **p
= (const char **) a
;
1986 const char **q
= (const char **) b
;
1987 return strcasecmp (*p
, *q
);
1993 clear_win32_environment (char **env
)
1997 wchar_t *copy
= NULL
, *equalpos
;
1999 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2001 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2002 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2003 mbstowcs (copy
, env
[i
], len
);
2004 equalpos
= wcschr (copy
, L
'=');
2007 SetEnvironmentVariableW (copy
, NULL
);
2013 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2014 EXEC_FILE is the file to run.
2015 ALLARGS is a string containing the arguments to the program.
2016 ENV is the environment vector to pass. Errors reported with error(). */
2019 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2020 char *allargs
, char **in_env
, int from_tty
)
2024 cygwin_buf_t real_path
[__PMAX
];
2025 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2027 cygwin_buf_t
*toexec
;
2028 cygwin_buf_t
*cygallargs
;
2030 char **old_env
= NULL
;
2034 int ostdin
, ostdout
, ostderr
;
2036 char real_path
[__PMAX
];
2037 char shell
[__PMAX
]; /* Path to shell */
2049 PROCESS_INFORMATION pi
;
2052 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2055 error (_("No executable specified, use `target exec'."));
2057 memset (&si
, 0, sizeof (si
));
2058 si
.cb
= sizeof (si
);
2061 flags
|= CREATE_NEW_PROCESS_GROUP
;
2064 windows_set_console_info (&si
, &flags
);
2069 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2070 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2071 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2072 error (_("Error starting executable: %d"), errno
);
2075 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2076 if (len
== (size_t) -1)
2077 error (_("Error starting executable: %d"), errno
);
2078 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2079 mbstowcs (cygallargs
, allargs
, len
);
2081 cygallargs
= allargs
;
2086 sh
= getenv ("SHELL");
2089 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2090 error (_("Error starting executable via shell: %d"), errno
);
2092 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2093 + mbstowcs (NULL
, allargs
, 0) + 2;
2094 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2095 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2097 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2098 + strlen (allargs
) + 2);
2099 cygallargs
= (char *) alloca (len
);
2100 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2103 flags
|= DEBUG_PROCESS
;
2107 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2108 * sizeof (wchar_t));
2109 wcscpy (args
, toexec
);
2110 wcscat (args
, L
" ");
2111 wcscat (args
, cygallargs
);
2113 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2114 strcpy (args
, toexec
);
2116 strcat (args
, cygallargs
);
2119 #ifdef CW_CVT_ENV_TO_WINENV
2120 /* First try to create a direct Win32 copy of the POSIX environment. */
2121 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2122 if (w32_env
!= (PWCHAR
) -1)
2123 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2125 /* If that fails, fall back to old method tweaking GDB's environment. */
2128 /* Reset all Win32 environment variables to avoid leftover on next run. */
2129 clear_win32_environment (environ
);
2130 /* Prepare the environment vars for CreateProcess. */
2133 cygwin_internal (CW_SYNC_WINENV
);
2137 if (!inferior_io_terminal
)
2138 tty
= ostdin
= ostdout
= ostderr
= -1;
2141 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2144 print_sys_errmsg (inferior_io_terminal
, errno
);
2145 ostdin
= ostdout
= ostderr
= -1;
2158 windows_init_thread_list ();
2159 ret
= CreateProcess (0,
2160 args
, /* command line */
2161 NULL
, /* Security */
2163 TRUE
, /* inherit handles */
2164 flags
, /* start flags */
2165 w32_env
, /* environment */
2166 NULL
, /* current directory */
2170 /* Just free the Win32 environment, if it could be created. */
2174 /* Reset all environment variables to avoid leftover on next run. */
2175 clear_win32_environment (in_env
);
2176 /* Restore normal GDB environment variables. */
2178 cygwin_internal (CW_SYNC_WINENV
);
2193 /* Build the command line, a space-separated list of tokens where
2194 the first token is the name of the module to be executed.
2195 To avoid ambiguities introduced by spaces in the module name,
2197 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2198 args
= alloca (args_len
);
2199 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2201 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2203 if (!inferior_io_terminal
)
2204 tty
= INVALID_HANDLE_VALUE
;
2207 SECURITY_ATTRIBUTES sa
;
2208 sa
.nLength
= sizeof(sa
);
2209 sa
.lpSecurityDescriptor
= 0;
2210 sa
.bInheritHandle
= TRUE
;
2211 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2212 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2213 if (tty
== INVALID_HANDLE_VALUE
)
2214 warning (_("Warning: Failed to open TTY %s, error %#x."),
2215 inferior_io_terminal
, (unsigned) GetLastError ());
2219 si
.hStdOutput
= tty
;
2221 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2225 /* CreateProcess takes the environment list as a null terminated set of
2226 strings (i.e. two nulls terminate the list). */
2228 /* Get total size for env strings. */
2229 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2230 envlen
+= strlen (in_env
[i
]) + 1;
2232 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2233 env
= (char **) alloca (envsize
);
2234 memcpy (env
, in_env
, envsize
);
2235 /* Windows programs expect the environment block to be sorted. */
2236 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2238 w32env
= alloca (envlen
+ 1);
2240 /* Copy env strings into new buffer. */
2241 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2243 strcpy (temp
, env
[i
]);
2244 temp
+= strlen (temp
) + 1;
2247 /* Final nil string to terminate new env. */
2250 windows_init_thread_list ();
2251 ret
= CreateProcessA (0,
2252 args
, /* command line */
2253 NULL
, /* Security */
2255 TRUE
, /* inherit handles */
2256 flags
, /* start flags */
2257 w32env
, /* environment */
2258 NULL
, /* current directory */
2261 if (tty
!= INVALID_HANDLE_VALUE
)
2266 error (_("Error creating process %s, (error %d)."),
2267 exec_file
, (unsigned) GetLastError ());
2269 CloseHandle (pi
.hThread
);
2270 CloseHandle (pi
.hProcess
);
2272 if (useshell
&& shell
[0] != '\0')
2277 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2279 /* windows_continue (DBG_CONTINUE, -1); */
2283 windows_mourn_inferior (struct target_ops
*ops
)
2285 (void) windows_continue (DBG_CONTINUE
, -1);
2286 i386_cleanup_dregs();
2287 if (open_process_used
)
2289 CHECK (CloseHandle (current_process_handle
));
2290 open_process_used
= 0;
2292 unpush_target (ops
);
2293 generic_mourn_inferior ();
2296 /* Send a SIGINT to the process group. This acts just like the user typed a
2297 ^C on the controlling terminal. */
2300 windows_stop (ptid_t ptid
)
2302 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2303 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2304 registers_changed (); /* refresh register state */
2308 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2309 int write
, struct mem_attrib
*mem
,
2310 struct target_ops
*target
)
2315 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2316 len
, (DWORD
) (uintptr_t) memaddr
));
2317 if (!WriteProcessMemory (current_process_handle
,
2318 (LPVOID
) (uintptr_t) memaddr
, our
,
2321 FlushInstructionCache (current_process_handle
,
2322 (LPCVOID
) (uintptr_t) memaddr
, len
);
2326 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2327 len
, (DWORD
) (uintptr_t) memaddr
));
2328 if (!ReadProcessMemory (current_process_handle
,
2329 (LPCVOID
) (uintptr_t) memaddr
, our
,
2337 windows_kill_inferior (struct target_ops
*ops
)
2339 CHECK (TerminateProcess (current_process_handle
, 0));
2343 if (!windows_continue (DBG_CONTINUE
, -1))
2345 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2347 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2351 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2355 windows_prepare_to_store (struct regcache
*regcache
)
2357 /* Do nothing, since we can store individual regs. */
2361 windows_can_run (void)
2367 windows_close (int x
)
2369 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2370 PIDGET (inferior_ptid
)));
2373 /* Convert pid to printable format. */
2375 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2377 static char buf
[80];
2379 if (ptid_get_tid (ptid
) != 0)
2381 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2382 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2386 return normal_pid_to_str (ptid
);
2390 windows_xfer_shared_libraries (struct target_ops
*ops
,
2391 enum target_object object
, const char *annex
,
2392 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2393 ULONGEST offset
, LONGEST len
)
2395 struct obstack obstack
;
2403 obstack_init (&obstack
);
2404 obstack_grow_str (&obstack
, "<library-list>\n");
2405 for (so
= solib_start
.next
; so
; so
= so
->next
)
2406 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2407 (uintptr_t) so
->lm_info
->load_addr
,
2408 target_gdbarch (), &obstack
);
2409 obstack_grow_str0 (&obstack
, "</library-list>\n");
2411 buf
= obstack_finish (&obstack
);
2412 len_avail
= strlen (buf
);
2413 if (offset
>= len_avail
)
2417 if (len
> len_avail
- offset
)
2418 len
= len_avail
- offset
;
2419 memcpy (readbuf
, buf
+ offset
, len
);
2422 obstack_free (&obstack
, NULL
);
2427 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2428 const char *annex
, gdb_byte
*readbuf
,
2429 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2433 case TARGET_OBJECT_MEMORY
:
2435 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2436 len
, 0/*read*/, NULL
, ops
);
2438 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2439 len
, 1/*write*/, NULL
, ops
);
2442 case TARGET_OBJECT_LIBRARIES
:
2443 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2444 writebuf
, offset
, len
);
2447 if (ops
->beneath
!= NULL
)
2448 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2449 readbuf
, writebuf
, offset
, len
);
2454 /* Provide thread local base, i.e. Thread Information Block address.
2455 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2458 windows_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2462 th
= thread_rec (ptid_get_tid (ptid
), 0);
2467 *addr
= th
->thread_local_base
;
2473 windows_get_ada_task_ptid (long lwp
, long thread
)
2475 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2479 init_windows_ops (void)
2481 windows_ops
.to_shortname
= "child";
2482 windows_ops
.to_longname
= "Win32 child process";
2483 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2484 windows_ops
.to_open
= windows_open
;
2485 windows_ops
.to_close
= windows_close
;
2486 windows_ops
.to_attach
= windows_attach
;
2487 windows_ops
.to_attach_no_wait
= 1;
2488 windows_ops
.to_detach
= windows_detach
;
2489 windows_ops
.to_resume
= windows_resume
;
2490 windows_ops
.to_wait
= windows_wait
;
2491 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2492 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2493 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2494 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2495 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2496 windows_ops
.to_files_info
= windows_files_info
;
2497 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2498 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2499 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2500 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2501 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2502 windows_ops
.to_terminal_ours
= terminal_ours
;
2503 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2504 windows_ops
.to_terminal_info
= child_terminal_info
;
2505 windows_ops
.to_kill
= windows_kill_inferior
;
2506 windows_ops
.to_create_inferior
= windows_create_inferior
;
2507 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2508 windows_ops
.to_can_run
= windows_can_run
;
2509 windows_ops
.to_thread_alive
= windows_thread_alive
;
2510 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2511 windows_ops
.to_stop
= windows_stop
;
2512 windows_ops
.to_stratum
= process_stratum
;
2513 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2514 windows_ops
.to_has_memory
= default_child_has_memory
;
2515 windows_ops
.to_has_stack
= default_child_has_stack
;
2516 windows_ops
.to_has_registers
= default_child_has_registers
;
2517 windows_ops
.to_has_execution
= default_child_has_execution
;
2518 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2519 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2520 windows_ops
.to_get_tib_address
= windows_get_tib_address
;
2522 i386_use_watchpoints (&windows_ops
);
2524 i386_dr_low
.set_control
= cygwin_set_dr7
;
2525 i386_dr_low
.set_addr
= cygwin_set_dr
;
2526 i386_dr_low
.get_addr
= cygwin_get_dr
;
2527 i386_dr_low
.get_status
= cygwin_get_dr6
;
2528 i386_dr_low
.get_control
= cygwin_get_dr7
;
2530 /* i386_dr_low.debug_register_length field is set by
2531 calling i386_set_debug_register_length function
2532 in processor windows specific native file. */
2534 windows_ops
.to_magic
= OPS_MAGIC
;
2538 set_windows_aliases (char *argv0
)
2540 add_info_alias ("dll", "sharedlibrary", 1);
2543 /* -Wmissing-prototypes */
2544 extern initialize_file_ftype _initialize_windows_nat
;
2547 _initialize_windows_nat (void)
2549 struct cmd_list_element
*c
;
2551 init_windows_ops ();
2554 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2557 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2558 _("Load dll library symbols from FILE."));
2559 set_cmd_completer (c
, filename_completer
);
2561 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2563 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2565 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2568 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2569 Set use of shell to start subprocess."), _("\
2570 Show use of shell to start subprocess."), NULL
,
2572 NULL
, /* FIXME: i18n: */
2573 &setlist
, &showlist
);
2575 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2576 &cygwin_exceptions
, _("\
2577 Break when an exception is detected in the Cygwin DLL itself."), _("\
2578 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2580 NULL
, /* FIXME: i18n: */
2581 &setlist
, &showlist
);
2584 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2585 Set creation of new console when creating child process."), _("\
2586 Show creation of new console when creating child process."), NULL
,
2588 NULL
, /* FIXME: i18n: */
2589 &setlist
, &showlist
);
2591 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2592 Set creation of new group when creating child process."), _("\
2593 Show creation of new group when creating child process."), NULL
,
2595 NULL
, /* FIXME: i18n: */
2596 &setlist
, &showlist
);
2598 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2599 Set whether to display execution in child process."), _("\
2600 Show whether to display execution in child process."), NULL
,
2602 NULL
, /* FIXME: i18n: */
2603 &setlist
, &showlist
);
2605 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2606 Set whether to display kernel events in child process."), _("\
2607 Show whether to display kernel events in child process."), NULL
,
2609 NULL
, /* FIXME: i18n: */
2610 &setlist
, &showlist
);
2612 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2613 Set whether to display memory accesses in child process."), _("\
2614 Show whether to display memory accesses in child process."), NULL
,
2616 NULL
, /* FIXME: i18n: */
2617 &setlist
, &showlist
);
2619 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2620 &debug_exceptions
, _("\
2621 Set whether to display kernel exceptions in child process."), _("\
2622 Show whether to display kernel exceptions in child process."), NULL
,
2624 NULL
, /* FIXME: i18n: */
2625 &setlist
, &showlist
);
2627 init_w32_command_list ();
2629 add_cmd ("selector", class_info
, display_selectors
,
2630 _("Display selectors infos."),
2632 add_target (&windows_ops
);
2633 deprecated_init_ui_hook
= set_windows_aliases
;
2636 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2638 /* Pass the address ADDR to the inferior in the I'th debug register.
2639 Here we just store the address in dr array, the registers will be
2640 actually set up when windows_continue is called. */
2642 cygwin_set_dr (int i
, CORE_ADDR addr
)
2645 internal_error (__FILE__
, __LINE__
,
2646 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2648 debug_registers_changed
= 1;
2649 debug_registers_used
= 1;
2652 /* Pass the value VAL to the inferior in the DR7 debug control
2653 register. Here we just store the address in D_REGS, the watchpoint
2654 will be actually set up in windows_wait. */
2656 cygwin_set_dr7 (unsigned long val
)
2658 dr
[7] = (CORE_ADDR
) val
;
2659 debug_registers_changed
= 1;
2660 debug_registers_used
= 1;
2663 /* Get the value of debug register I from the inferior. */
2666 cygwin_get_dr (int i
)
2671 /* Get the value of the DR6 debug status register from the inferior.
2672 Here we just return the value stored in dr[6]
2673 by the last call to thread_rec for current_event.dwThreadId id. */
2674 static unsigned long
2675 cygwin_get_dr6 (void)
2677 return (unsigned long) dr
[6];
2680 /* Get the value of the DR7 debug status register from the inferior.
2681 Here we just return the value stored in dr[7] by the last call to
2682 thread_rec for current_event.dwThreadId id. */
2684 static unsigned long
2685 cygwin_get_dr7 (void)
2687 return (unsigned long) dr
[7];
2690 /* Determine if the thread referenced by "ptid" is alive
2691 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2692 it means that the thread has died. Otherwise it is assumed to be alive. */
2694 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2698 gdb_assert (ptid_get_tid (ptid
) != 0);
2699 tid
= ptid_get_tid (ptid
);
2701 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2705 /* -Wmissing-prototypes */
2706 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2709 _initialize_check_for_gdb_ini (void)
2712 if (inhibit_gdbinit
)
2715 homedir
= getenv ("HOME");
2719 char *oldini
= (char *) alloca (strlen (homedir
) +
2720 sizeof ("/gdb.ini"));
2721 strcpy (oldini
, homedir
);
2722 p
= strchr (oldini
, '\0');
2723 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2725 strcpy (p
, "gdb.ini");
2726 if (access (oldini
, 0) == 0)
2728 int len
= strlen (oldini
);
2729 char *newini
= alloca (len
+ 1);
2731 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2732 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2733 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2738 /* Define dummy functions which always return error for the rare cases where
2739 these functions could not be found. */
2741 bad_DebugActiveProcessStop (DWORD w
)
2746 bad_DebugBreakProcess (HANDLE w
)
2751 bad_DebugSetProcessKillOnExit (BOOL w
)
2756 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2763 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2769 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2776 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2782 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2788 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2794 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2802 /* -Wmissing-prototypes */
2803 extern initialize_file_ftype _initialize_loadable
;
2805 /* Load any functions which may not be available in ancient versions
2809 _initialize_loadable (void)
2813 hm
= LoadLibrary ("kernel32.dll");
2816 DebugActiveProcessStop
= (void *)
2817 GetProcAddress (hm
, "DebugActiveProcessStop");
2818 DebugBreakProcess
= (void *)
2819 GetProcAddress (hm
, "DebugBreakProcess");
2820 DebugSetProcessKillOnExit
= (void *)
2821 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2822 GetConsoleFontSize
= (void *)
2823 GetProcAddress (hm
, "GetConsoleFontSize");
2824 GetCurrentConsoleFont
= (void *)
2825 GetProcAddress (hm
, "GetCurrentConsoleFont");
2828 /* Set variables to dummy versions of these processes if the function
2829 wasn't found in kernel32.dll. */
2830 if (!DebugBreakProcess
)
2831 DebugBreakProcess
= bad_DebugBreakProcess
;
2832 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2834 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2835 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2837 if (!GetConsoleFontSize
)
2838 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2839 if (!GetCurrentConsoleFont
)
2840 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2842 /* Load optional functions used for retrieving filename information
2843 associated with the currently debugged process or its dlls. */
2844 hm
= LoadLibrary ("psapi.dll");
2847 EnumProcessModules
= (void *)
2848 GetProcAddress (hm
, "EnumProcessModules");
2849 GetModuleInformation
= (void *)
2850 GetProcAddress (hm
, "GetModuleInformation");
2851 GetModuleFileNameEx
= (void *)
2852 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2855 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2857 /* Set variables to dummy versions of these processes if the function
2858 wasn't found in psapi.dll. */
2859 EnumProcessModules
= bad_EnumProcessModules
;
2860 GetModuleInformation
= bad_GetModuleInformation
;
2861 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2862 /* This will probably fail on Windows 9x/Me. Let the user know
2863 that we're missing some functionality. */
2865 cannot automatically find executable file or library to read symbols.\n\
2866 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2869 hm
= LoadLibrary ("advapi32.dll");
2872 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2873 LookupPrivilegeValueA
= (void *)
2874 GetProcAddress (hm
, "LookupPrivilegeValueA");
2875 AdjustTokenPrivileges
= (void *)
2876 GetProcAddress (hm
, "AdjustTokenPrivileges");
2877 /* Only need to set one of these since if OpenProcessToken fails nothing
2879 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2880 || !AdjustTokenPrivileges
)
2881 OpenProcessToken
= bad_OpenProcessToken
;