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
, DWORD exit_code
)
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 else if (print_thread_events
&& id
!= main_thread_id
)
401 printf_unfiltered (_("[%s exited with code %u]\n"),
402 target_pid_to_str (ptid
), (unsigned)exit_code
);
403 delete_thread (ptid
);
405 for (th
= &thread_head
;
406 th
->next
!= NULL
&& th
->next
->id
!= id
;
410 if (th
->next
!= NULL
)
412 thread_info
*here
= th
->next
;
413 th
->next
= here
->next
;
419 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
421 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
422 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
423 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
427 return; /* Windows sometimes uses a non-existent thread id in its
430 if (current_thread
->reload_context
)
432 #ifdef __COPY_CONTEXT_SIZE
433 if (have_saved_context
)
435 /* Lie about where the program actually is stopped since
436 cygwin has informed us that we should consider the signal
437 to have occurred at another location which is stored in
439 memcpy (¤t_thread
->context
, &saved_context
,
440 __COPY_CONTEXT_SIZE
);
441 have_saved_context
= 0;
446 thread_info
*th
= current_thread
;
447 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
448 GetThreadContext (th
->h
, &th
->context
);
449 /* Copy dr values from that thread.
450 But only if there were not modified since last stop.
452 if (!debug_registers_changed
)
454 dr
[0] = th
->context
.Dr0
;
455 dr
[1] = th
->context
.Dr1
;
456 dr
[2] = th
->context
.Dr2
;
457 dr
[3] = th
->context
.Dr3
;
458 dr
[6] = th
->context
.Dr6
;
459 dr
[7] = th
->context
.Dr7
;
462 current_thread
->reload_context
= 0;
465 if (r
== I387_FISEG_REGNUM (tdep
))
467 l
= *((long *) context_offset
) & 0xffff;
468 regcache_raw_supply (regcache
, r
, (char *) &l
);
470 else if (r
== I387_FOP_REGNUM (tdep
))
472 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
473 regcache_raw_supply (regcache
, r
, (char *) &l
);
475 else if (segment_register_p (r
))
477 /* GDB treats segment registers as 32bit registers, but they are
478 in fact only 16 bits long. Make sure we do not read extra
479 bits from our source buffer. */
480 l
= *((long *) context_offset
) & 0xffff;
481 regcache_raw_supply (regcache
, r
, (char *) &l
);
484 regcache_raw_supply (regcache
, r
, context_offset
);
487 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
488 do_windows_fetch_inferior_registers (regcache
, r
);
493 windows_fetch_inferior_registers (struct target_ops
*ops
,
494 struct regcache
*regcache
, int r
)
496 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
497 /* Check if current_thread exists. Windows sometimes uses a non-existent
498 thread id in its events. */
500 do_windows_fetch_inferior_registers (regcache
, r
);
504 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
507 /* Windows sometimes uses a non-existent thread id in its events. */;
509 regcache_raw_collect (regcache
, r
,
510 ((char *) ¤t_thread
->context
) + mappings
[r
]);
513 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
514 do_windows_store_inferior_registers (regcache
, r
);
518 /* Store a new register value into the current thread context. */
520 windows_store_inferior_registers (struct target_ops
*ops
,
521 struct regcache
*regcache
, int r
)
523 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
524 /* Check if current_thread exists. Windows sometimes uses a non-existent
525 thread id in its events. */
527 do_windows_store_inferior_registers (regcache
, r
);
530 /* Get the name of a given module at given base address. If base_address
531 is zero return the first loaded module (which is always the name of the
534 get_module_name (LPVOID base_address
, char *dll_name_ret
)
540 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for
544 cygwin_buf_t pathbuf
[__PMAX
]; /* Temporary storage prior to converting to
545 posix form. __PMAX is always enough
546 as long as SO_NAME_MAX_PATH_SIZE is defined
551 /* Find size of buffer needed to handle list of modules loaded in
553 if (!EnumProcessModules (current_process_handle
, DllHandle
,
554 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
557 /* Allocate correct amount of space for module list. */
558 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
562 /* Get the list of modules. */
563 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
567 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
569 /* Get information on this module. */
570 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
572 error (_("Can't get module info"));
574 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
576 /* Try to find the name of the given module. */
578 /* Cygwin prefers that the path be in /x/y/z format. */
579 len
= GetModuleFileNameEx (current_process_handle
,
580 DllHandle
[i
], pathbuf
, __PMAX
);
582 error (_("Error getting dll name: %u."),
583 (unsigned) GetLastError ());
584 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
586 error (_("Error converting dll name to POSIX: %d."), errno
);
588 len
= GetModuleFileNameEx (current_process_handle
,
589 DllHandle
[i
], dll_name_ret
, __PMAX
);
591 error (_("Error getting dll name: %u."),
592 (unsigned) GetLastError ());
594 return 1; /* success */
599 dll_name_ret
[0] = '\0';
600 return 0; /* failure */
603 /* Encapsulate the information required in a call to
604 symbol_file_add_args. */
605 struct safe_symbol_file_add_args
609 struct section_addr_info
*addrs
;
612 struct ui_file
*err
, *out
;
616 /* Maintain a linked list of "so" information. */
622 static struct so_list solib_start
, *solib_end
;
624 /* Call symbol_file_add with stderr redirected. We don't care if there
627 safe_symbol_file_add_stub (void *argv
)
629 #define p ((struct safe_symbol_file_add_args *) argv)
630 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
631 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
632 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
637 /* Restore gdb's stderr after calling symbol_file_add. */
639 safe_symbol_file_add_cleanup (void *p
)
641 #define sp ((struct safe_symbol_file_add_args *)p)
642 gdb_flush (gdb_stderr
);
643 gdb_flush (gdb_stdout
);
644 ui_file_delete (gdb_stderr
);
645 ui_file_delete (gdb_stdout
);
646 gdb_stderr
= sp
->err
;
647 gdb_stdout
= sp
->out
;
651 /* symbol_file_add wrapper that prevents errors from being displayed. */
652 static struct objfile
*
653 safe_symbol_file_add (char *name
, int from_tty
,
654 struct section_addr_info
*addrs
,
655 int mainline
, int flags
)
657 struct safe_symbol_file_add_args p
;
658 struct cleanup
*cleanup
;
660 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
664 gdb_flush (gdb_stderr
);
665 gdb_flush (gdb_stdout
);
666 gdb_stderr
= ui_file_new ();
667 gdb_stdout
= ui_file_new ();
669 p
.from_tty
= from_tty
;
671 p
.mainline
= mainline
;
673 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
675 do_cleanups (cleanup
);
679 static struct so_list
*
680 windows_make_so (const char *name
, LPVOID load_addr
)
687 WIN32_FIND_DATA w32_fd
;
688 HANDLE h
= FindFirstFile(name
, &w32_fd
);
690 if (h
== INVALID_HANDLE_VALUE
)
696 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
698 p
= strrchr (buf
, '\\');
701 SetCurrentDirectory (buf
);
702 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
703 SetCurrentDirectory (cwd
);
706 if (strcasecmp (buf
, "ntdll.dll") == 0)
708 GetSystemDirectory (buf
, sizeof (buf
));
709 strcat (buf
, "\\ntdll.dll");
712 cygwin_buf_t buf
[__PMAX
];
715 if (access (name
, F_OK
) != 0)
717 if (strcasecmp (name
, "ntdll.dll") == 0)
720 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
721 wcscat (buf
, L
"\\ntdll.dll");
725 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
726 strcat (buf
, "\\ntdll.dll");
731 so
= XZALLOC (struct so_list
);
732 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
733 so
->lm_info
->load_addr
= load_addr
;
734 strcpy (so
->so_original_name
, name
);
736 strcpy (so
->so_name
, buf
);
739 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
740 SO_NAME_MAX_PATH_SIZE
);
743 char *rname
= realpath (name
, NULL
);
744 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
746 strcpy (so
->so_name
, rname
);
750 error (_("dll path too long"));
752 /* Record cygwin1.dll .text start/end. */
753 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
754 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
757 asection
*text
= NULL
;
760 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
765 if (bfd_check_format (abfd
, bfd_object
))
766 text
= bfd_get_section_by_name (abfd
, ".text");
770 gdb_bfd_unref (abfd
);
774 /* The symbols in a dll are offset by 0x1000, which is the
775 offset from 0 of the first byte in an image - because of the
776 file header and the section alignment. */
777 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
779 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
781 gdb_bfd_unref (abfd
);
789 get_image_name (HANDLE h
, void *address
, int unicode
)
792 static char buf
[__PMAX
];
794 static char buf
[(2 * __PMAX
) + 1];
796 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
802 /* Attempt to read the name of the dll that was detected.
803 This is documented to work only when actively debugging
804 a program. It will not work for attached processes. */
808 /* See if we could read the address of a string, and that the
809 address isn't null. */
810 if (!ReadProcessMemory (h
, address
, &address_ptr
,
811 sizeof (address_ptr
), &done
)
812 || done
!= sizeof (address_ptr
) || !address_ptr
)
815 /* Find the length of the string. */
816 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
817 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
821 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
824 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
825 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
828 wcstombs (buf
, unicode_address
, __PMAX
);
830 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
838 /* Wait for child to do something. Return pid of child, or -1 in case
839 of error; store status through argument pointer OURSTATUS. */
841 handle_load_dll (void *dummy
)
843 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
844 char dll_buf
[__PMAX
];
845 char *dll_name
= NULL
;
847 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
849 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
850 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
854 if (*dll_name
== '\0')
855 dll_name
= get_image_name (current_process_handle
,
856 event
->lpImageName
, event
->fUnicode
);
860 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
861 solib_end
= solib_end
->next
;
863 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
864 host_address_to_string (solib_end
->lm_info
->load_addr
)));
870 windows_free_so (struct so_list
*so
)
878 handle_unload_dll (void *dummy
)
880 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
883 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
884 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
886 struct so_list
*sodel
= so
->next
;
888 so
->next
= sodel
->next
;
891 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
893 windows_free_so (sodel
);
897 /* We did not find any DLL that was previously loaded at this address,
898 so register a complaint. We do not report an error, because we have
899 observed that this may be happening under some circumstances. For
900 instance, running 32bit applications on x64 Windows causes us to receive
901 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
902 events are apparently caused by the WOW layer, the interface between
903 32bit and 64bit worlds). */
904 complaint (&symfile_complaints
, _("dll starting at %s not found."),
905 host_address_to_string (lpBaseOfDll
));
910 /* Clear list of loaded DLLs. */
912 windows_clear_solib (void)
914 solib_start
.next
= NULL
;
915 solib_end
= &solib_start
;
918 /* Load DLL symbol info. */
920 dll_symbol_command (char *args
, int from_tty
)
926 error (_("dll-symbols requires a file name"));
929 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
931 char *newargs
= (char *) alloca (n
+ 4 + 1);
932 strcpy (newargs
, args
);
933 strcat (newargs
, ".dll");
937 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
940 /* Handle DEBUG_STRING output from child process.
941 Cygwin prepends its messages with a "cygwin:". Interpret this as
942 a Cygwin signal. Otherwise just print the string as a warning. */
944 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
949 if (!target_read_string
950 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
954 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
955 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
958 if (strncmp (s
, "cYg", 3) != 0)
962 #ifdef __COPY_CONTEXT_SIZE
965 /* Got a cygwin signal marker. A cygwin signal is followed by
966 the signal number itself and then optionally followed by the
967 thread id and address to saved context within the DLL. If
968 these are supplied, then the given thread is assumed to have
969 issued the signal and the context from the thread is assumed
970 to be stored at the given address in the inferior. Tell gdb
971 to treat this like a real signal. */
973 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
974 int gotasig
= gdb_signal_from_host (sig
);
976 ourstatus
->value
.sig
= gotasig
;
982 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
983 retval
= strtoul (p
, &p
, 0);
985 retval
= main_thread_id
;
986 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
987 && ReadProcessMemory (current_process_handle
, x
,
989 __COPY_CONTEXT_SIZE
, &n
)
990 && n
== __COPY_CONTEXT_SIZE
)
991 have_saved_context
= 1;
992 current_event
.dwThreadId
= retval
;
1003 display_selector (HANDLE thread
, DWORD sel
)
1006 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1009 printf_filtered ("0x%03x: ", (unsigned) sel
);
1010 if (!info
.HighWord
.Bits
.Pres
)
1012 puts_filtered ("Segment not present\n");
1015 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1016 (info
.HighWord
.Bits
.BaseMid
<< 16)
1018 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1019 if (info
.HighWord
.Bits
.Granularity
)
1020 limit
= (limit
<< 12) | 0xfff;
1021 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1022 if (info
.HighWord
.Bits
.Default_Big
)
1023 puts_filtered(" 32-bit ");
1025 puts_filtered(" 16-bit ");
1026 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1029 puts_filtered ("Data (Read-Only, Exp-up");
1032 puts_filtered ("Data (Read/Write, Exp-up");
1035 puts_filtered ("Unused segment (");
1038 puts_filtered ("Data (Read/Write, Exp-down");
1041 puts_filtered ("Code (Exec-Only, N.Conf");
1044 puts_filtered ("Code (Exec/Read, N.Conf");
1047 puts_filtered ("Code (Exec-Only, Conf");
1050 puts_filtered ("Code (Exec/Read, Conf");
1053 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1055 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1056 puts_filtered(", N.Acc");
1057 puts_filtered (")\n");
1058 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1059 puts_filtered("System selector ");
1060 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1061 if (info
.HighWord
.Bits
.Granularity
)
1062 puts_filtered ("Page granular.\n");
1064 puts_filtered ("Byte granular.\n");
1069 DWORD err
= GetLastError ();
1070 if (err
== ERROR_NOT_SUPPORTED
)
1071 printf_filtered ("Function not supported\n");
1073 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1079 display_selectors (char * args
, int from_tty
)
1081 if (!current_thread
)
1083 puts_filtered ("Impossible to display selectors now.\n");
1089 puts_filtered ("Selector $cs\n");
1090 display_selector (current_thread
->h
,
1091 current_thread
->context
.SegCs
);
1092 puts_filtered ("Selector $ds\n");
1093 display_selector (current_thread
->h
,
1094 current_thread
->context
.SegDs
);
1095 puts_filtered ("Selector $es\n");
1096 display_selector (current_thread
->h
,
1097 current_thread
->context
.SegEs
);
1098 puts_filtered ("Selector $ss\n");
1099 display_selector (current_thread
->h
,
1100 current_thread
->context
.SegSs
);
1101 puts_filtered ("Selector $fs\n");
1102 display_selector (current_thread
->h
,
1103 current_thread
->context
.SegFs
);
1104 puts_filtered ("Selector $gs\n");
1105 display_selector (current_thread
->h
,
1106 current_thread
->context
.SegGs
);
1111 sel
= parse_and_eval_long (args
);
1112 printf_filtered ("Selector \"%s\"\n",args
);
1113 display_selector (current_thread
->h
, sel
);
1117 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1118 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1119 host_address_to_string (\
1120 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1123 handle_exception (struct target_waitstatus
*ourstatus
)
1126 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1128 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1130 /* Record the context of the current thread. */
1131 th
= thread_rec (current_event
.dwThreadId
, -1);
1135 case EXCEPTION_ACCESS_VIOLATION
:
1136 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1137 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1140 /* See if the access violation happened within the cygwin DLL
1141 itself. Cygwin uses a kind of exception handling to deal
1142 with passed-in invalid addresses. gdb should not treat
1143 these as real SEGVs since they will be silently handled by
1144 cygwin. A real SEGV will (theoretically) be caught by
1145 cygwin later in the process and will be sent as a
1146 cygwin-specific-signal. So, ignore SEGVs if they show up
1147 within the text segment of the DLL itself. */
1149 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1150 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1152 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1153 && addr
< cygwin_load_end
))
1154 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1155 && strncmp (fn
, "KERNEL32!IsBad",
1156 strlen ("KERNEL32!IsBad")) == 0))
1161 case STATUS_STACK_OVERFLOW
:
1162 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1163 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1165 case STATUS_FLOAT_DENORMAL_OPERAND
:
1166 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1167 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1169 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1170 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1171 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1173 case STATUS_FLOAT_INEXACT_RESULT
:
1174 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1175 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1177 case STATUS_FLOAT_INVALID_OPERATION
:
1178 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1179 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1181 case STATUS_FLOAT_OVERFLOW
:
1182 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1183 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1185 case STATUS_FLOAT_STACK_CHECK
:
1186 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1187 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1189 case STATUS_FLOAT_UNDERFLOW
:
1190 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1191 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1193 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1194 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1195 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1197 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1198 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1199 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1201 case STATUS_INTEGER_OVERFLOW
:
1202 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1203 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1205 case EXCEPTION_BREAKPOINT
:
1206 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1207 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1210 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1211 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1213 case DBG_CONTROL_BREAK
:
1214 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1215 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1217 case EXCEPTION_SINGLE_STEP
:
1218 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1219 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1221 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1222 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1223 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1225 case EXCEPTION_PRIV_INSTRUCTION
:
1226 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1227 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1229 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1230 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1231 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1234 /* Treat unhandled first chance exceptions specially. */
1235 if (current_event
.u
.Exception
.dwFirstChance
)
1237 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1238 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1239 host_address_to_string (
1240 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1241 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1245 last_sig
= ourstatus
->value
.sig
;
1249 /* Resume all artificially suspended threads if we are continuing
1252 windows_continue (DWORD continue_status
, int id
)
1258 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%x, %s);\n",
1259 (unsigned) current_event
.dwProcessId
,
1260 (unsigned) current_event
.dwThreadId
,
1261 continue_status
== DBG_CONTINUE
?
1262 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1264 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1265 if ((id
== -1 || id
== (int) th
->id
)
1268 if (debug_registers_changed
)
1270 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1271 th
->context
.Dr0
= dr
[0];
1272 th
->context
.Dr1
= dr
[1];
1273 th
->context
.Dr2
= dr
[2];
1274 th
->context
.Dr3
= dr
[3];
1275 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1276 th
->context
.Dr7
= dr
[7];
1278 if (th
->context
.ContextFlags
)
1280 CHECK (SetThreadContext (th
->h
, &th
->context
));
1281 th
->context
.ContextFlags
= 0;
1283 if (th
->suspended
> 0)
1284 (void) ResumeThread (th
->h
);
1288 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1289 current_event
.dwThreadId
,
1292 debug_registers_changed
= 0;
1296 /* Called in pathological case where Windows fails to send a
1297 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1299 fake_create_process (void)
1301 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1302 current_event
.dwProcessId
);
1303 if (current_process_handle
!= NULL
)
1304 open_process_used
= 1;
1307 error (_("OpenProcess call failed, GetLastError = %u"),
1308 (unsigned) GetLastError ());
1309 /* We can not debug anything in that case. */
1311 main_thread_id
= current_event
.dwThreadId
;
1312 current_thread
= windows_add_thread (
1313 ptid_build (current_event
.dwProcessId
, 0,
1314 current_event
.dwThreadId
),
1315 current_event
.u
.CreateThread
.hThread
,
1316 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1317 return main_thread_id
;
1321 windows_resume (struct target_ops
*ops
,
1322 ptid_t ptid
, int step
, enum gdb_signal sig
)
1325 DWORD continue_status
= DBG_CONTINUE
;
1327 /* A specific PTID means `step only this thread id'. */
1328 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1330 /* If we're continuing all threads, it's the current inferior that
1331 should be handled specially. */
1333 ptid
= inferior_ptid
;
1335 if (sig
!= GDB_SIGNAL_0
)
1337 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1339 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1341 else if (sig
== last_sig
)
1342 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1345 /* This code does not seem to work, because
1346 the kernel does probably not consider changes in the ExceptionRecord
1347 structure when passing the exception to the inferior.
1348 Note that this seems possible in the exception handler itself. */
1351 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1352 if (xlate
[i
].us
== sig
)
1354 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1356 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1359 if (continue_status
== DBG_CONTINUE
)
1361 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1365 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1369 last_sig
= GDB_SIGNAL_0
;
1371 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1372 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1374 /* Get context for currently selected thread. */
1375 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1380 /* Single step by setting t bit. */
1381 struct regcache
*regcache
= get_current_regcache ();
1382 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1383 windows_fetch_inferior_registers (ops
, regcache
,
1384 gdbarch_ps_regnum (gdbarch
));
1385 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1388 if (th
->context
.ContextFlags
)
1390 if (debug_registers_changed
)
1392 th
->context
.Dr0
= dr
[0];
1393 th
->context
.Dr1
= dr
[1];
1394 th
->context
.Dr2
= dr
[2];
1395 th
->context
.Dr3
= dr
[3];
1396 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1397 th
->context
.Dr7
= dr
[7];
1399 CHECK (SetThreadContext (th
->h
, &th
->context
));
1400 th
->context
.ContextFlags
= 0;
1404 /* Allow continuing with the same signal that interrupted us.
1405 Otherwise complain. */
1408 windows_continue (continue_status
, -1);
1410 windows_continue (continue_status
, ptid_get_tid (ptid
));
1413 /* Ctrl-C handler used when the inferior is not run in the same console. The
1414 handler is in charge of interrupting the inferior using DebugBreakProcess.
1415 Note that this function is not available prior to Windows XP. In this case
1416 we emit a warning. */
1418 ctrl_c_handler (DWORD event_type
)
1420 const int attach_flag
= current_inferior ()->attach_flag
;
1422 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1423 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1426 /* If the inferior and the debugger share the same console, do nothing as
1427 the inferior has also received the Ctrl-C event. */
1428 if (!new_console
&& !attach_flag
)
1431 if (!DebugBreakProcess (current_process_handle
))
1432 warning (_("Could not interrupt program. "
1433 "Press Ctrl-c in the program console."));
1435 /* Return true to tell that Ctrl-C has been handled. */
1439 /* Get the next event from the child. Return 1 if the event requires
1440 handling by WFI (or whatever). */
1442 get_windows_debug_event (struct target_ops
*ops
,
1443 int pid
, struct target_waitstatus
*ourstatus
)
1446 DWORD continue_status
, event_code
;
1448 static thread_info dummy_thread_info
;
1451 last_sig
= GDB_SIGNAL_0
;
1453 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1457 continue_status
= DBG_CONTINUE
;
1459 event_code
= current_event
.dwDebugEventCode
;
1460 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1462 have_saved_context
= 0;
1466 case CREATE_THREAD_DEBUG_EVENT
:
1467 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1468 (unsigned) current_event
.dwProcessId
,
1469 (unsigned) current_event
.dwThreadId
,
1470 "CREATE_THREAD_DEBUG_EVENT"));
1471 if (saw_create
!= 1)
1473 struct inferior
*inf
;
1474 inf
= find_inferior_pid (current_event
.dwProcessId
);
1475 if (!saw_create
&& inf
->attach_flag
)
1477 /* Kludge around a Windows bug where first event is a create
1478 thread event. Caused when attached process does not have
1480 retval
= fake_create_process ();
1486 /* Record the existence of this thread. */
1487 retval
= current_event
.dwThreadId
;
1488 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1489 current_event
.dwThreadId
),
1490 current_event
.u
.CreateThread
.hThread
,
1491 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1495 case EXIT_THREAD_DEBUG_EVENT
:
1496 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1497 (unsigned) current_event
.dwProcessId
,
1498 (unsigned) current_event
.dwThreadId
,
1499 "EXIT_THREAD_DEBUG_EVENT"));
1501 if (current_event
.dwThreadId
!= main_thread_id
)
1503 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1504 current_event
.dwThreadId
),
1505 current_event
.u
.ExitThread
.dwExitCode
);
1506 th
= &dummy_thread_info
;
1510 case CREATE_PROCESS_DEBUG_EVENT
:
1511 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1512 (unsigned) current_event
.dwProcessId
,
1513 (unsigned) current_event
.dwThreadId
,
1514 "CREATE_PROCESS_DEBUG_EVENT"));
1515 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1516 if (++saw_create
!= 1)
1519 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1521 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1524 main_thread_id
= current_event
.dwThreadId
;
1525 /* Add the main thread. */
1526 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1527 current_event
.dwThreadId
),
1528 current_event
.u
.CreateProcessInfo
.hThread
,
1529 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1530 retval
= current_event
.dwThreadId
;
1533 case EXIT_PROCESS_DEBUG_EVENT
:
1534 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1535 (unsigned) current_event
.dwProcessId
,
1536 (unsigned) current_event
.dwThreadId
,
1537 "EXIT_PROCESS_DEBUG_EVENT"));
1538 if (!windows_initialization_done
)
1540 target_terminal_ours ();
1541 target_mourn_inferior ();
1542 error (_("During startup program exited with code 0x%x."),
1543 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1545 else if (saw_create
== 1)
1547 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1548 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1549 retval
= main_thread_id
;
1553 case LOAD_DLL_DEBUG_EVENT
:
1554 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1555 (unsigned) current_event
.dwProcessId
,
1556 (unsigned) current_event
.dwThreadId
,
1557 "LOAD_DLL_DEBUG_EVENT"));
1558 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1559 if (saw_create
!= 1)
1561 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1562 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1563 ourstatus
->value
.integer
= 0;
1564 retval
= main_thread_id
;
1567 case UNLOAD_DLL_DEBUG_EVENT
:
1568 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1569 (unsigned) current_event
.dwProcessId
,
1570 (unsigned) current_event
.dwThreadId
,
1571 "UNLOAD_DLL_DEBUG_EVENT"));
1572 if (saw_create
!= 1)
1574 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1575 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1576 ourstatus
->value
.integer
= 0;
1577 retval
= main_thread_id
;
1580 case EXCEPTION_DEBUG_EVENT
:
1581 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1582 (unsigned) current_event
.dwProcessId
,
1583 (unsigned) current_event
.dwThreadId
,
1584 "EXCEPTION_DEBUG_EVENT"));
1585 if (saw_create
!= 1)
1587 switch (handle_exception (ourstatus
))
1590 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1593 retval
= current_event
.dwThreadId
;
1597 continue_status
= -1;
1602 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1603 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1604 (unsigned) current_event
.dwProcessId
,
1605 (unsigned) current_event
.dwThreadId
,
1606 "OUTPUT_DEBUG_STRING_EVENT"));
1607 if (saw_create
!= 1)
1609 retval
= handle_output_debug_string (ourstatus
);
1613 if (saw_create
!= 1)
1615 printf_unfiltered ("gdb: kernel event for pid=%u tid=%x\n",
1616 (unsigned) current_event
.dwProcessId
,
1617 (unsigned) current_event
.dwThreadId
);
1618 printf_unfiltered (" unknown event code %u\n",
1619 (unsigned) current_event
.dwDebugEventCode
);
1623 if (!retval
|| saw_create
!= 1)
1625 if (continue_status
== -1)
1626 windows_resume (ops
, minus_one_ptid
, 0, 1);
1628 CHECK (windows_continue (continue_status
, -1));
1632 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1634 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1641 /* Wait for interesting events to occur in the target process. */
1643 windows_wait (struct target_ops
*ops
,
1644 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1648 target_terminal_ours ();
1650 /* We loop when we get a non-standard exception rather than return
1651 with a SPURIOUS because resume can try and step or modify things,
1652 which needs a current_thread->h. But some of these exceptions mark
1653 the birth or death of threads, which mean that the current thread
1654 isn't necessarily what you think it is. */
1660 /* If the user presses Ctrl-c while the debugger is waiting
1661 for an event, he expects the debugger to interrupt his program
1662 and to get the prompt back. There are two possible situations:
1664 - The debugger and the program do not share the console, in
1665 which case the Ctrl-c event only reached the debugger.
1666 In that case, the ctrl_c handler will take care of interrupting
1667 the inferior. Note that this case is working starting with
1668 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1671 - The debugger and the program share the same console, in which
1672 case both debugger and inferior will receive the Ctrl-c event.
1673 In that case the ctrl_c handler will ignore the event, as the
1674 Ctrl-c event generated inside the inferior will trigger the
1675 expected debug event.
1677 FIXME: brobecker/2008-05-20: If the inferior receives the
1678 signal first and the delay until GDB receives that signal
1679 is sufficiently long, GDB can sometimes receive the SIGINT
1680 after we have unblocked the CTRL+C handler. This would
1681 lead to the debugger stopping prematurely while handling
1682 the new-thread event that comes with the handling of the SIGINT
1683 inside the inferior, and then stop again immediately when
1684 the user tries to resume the execution in the inferior.
1685 This is a classic race that we should try to fix one day. */
1686 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1687 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1688 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1691 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1696 if (deprecated_ui_loop_hook
!= NULL
)
1697 detach
= deprecated_ui_loop_hook (0);
1700 windows_kill_inferior (ops
);
1706 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1708 extern int stop_after_trap
;
1710 struct inferior
*inf
;
1711 struct thread_info
*tp
;
1713 last_sig
= GDB_SIGNAL_0
;
1715 exception_count
= 0;
1716 open_process_used
= 0;
1717 debug_registers_changed
= 0;
1718 debug_registers_used
= 0;
1719 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1722 cygwin_load_start
= cygwin_load_end
= 0;
1724 current_event
.dwProcessId
= pid
;
1725 memset (¤t_event
, 0, sizeof (current_event
));
1727 disable_breakpoints_in_shlibs ();
1728 windows_clear_solib ();
1729 clear_proceed_status ();
1730 init_wait_for_inferior ();
1732 inf
= current_inferior ();
1733 inferior_appeared (inf
, pid
);
1734 inf
->attach_flag
= attaching
;
1736 /* Make the new process the current inferior, so terminal handling
1737 can rely on it. When attaching, we don't know about any thread
1738 id here, but that's OK --- nothing should be referencing the
1739 current thread until we report an event out of windows_wait. */
1740 inferior_ptid
= pid_to_ptid (pid
);
1742 terminal_init_inferior_with_pgrp (pid
);
1743 target_terminal_inferior ();
1745 windows_initialization_done
= 0;
1746 inf
->control
.stop_soon
= STOP_QUIETLY
;
1749 stop_after_trap
= 1;
1750 wait_for_inferior ();
1751 tp
= inferior_thread ();
1752 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1753 resume (0, tp
->suspend
.stop_signal
);
1758 windows_initialization_done
= 1;
1759 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1760 stop_after_trap
= 0;
1764 /* Try to set or remove a user privilege to the current process. Return -1
1765 if that fails, the previous setting of that privilege otherwise.
1767 This code is copied from the Cygwin source code and rearranged to allow
1768 dynamically loading of the needed symbols from advapi32 which is only
1769 available on NT/2K/XP. */
1771 set_process_privilege (const char *privilege
, BOOL enable
)
1773 HANDLE token_hdl
= NULL
;
1775 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1779 if (!OpenProcessToken (GetCurrentProcess (),
1780 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1784 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1787 new_priv
.PrivilegeCount
= 1;
1788 new_priv
.Privileges
[0].Luid
= restore_priv
;
1789 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1791 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1792 sizeof orig_priv
, &orig_priv
, &size
))
1795 /* Disabled, otherwise every `attach' in an unprivileged user session
1796 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1797 windows_attach(). */
1798 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1799 be enabled. GetLastError () returns an correct error code, though. */
1800 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1804 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1808 CloseHandle (token_hdl
);
1813 /* Attach to process PID, then initialize for debugging it. */
1815 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1820 pid
= parse_pid_to_attach (args
);
1822 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1824 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1825 printf_unfiltered ("This can cause attach to "
1826 "fail on Windows NT/2K/XP\n");
1829 windows_init_thread_list ();
1830 ok
= DebugActiveProcess (pid
);
1836 /* Try fall back to Cygwin pid. */
1837 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1840 ok
= DebugActiveProcess (pid
);
1845 error (_("Can't attach to process."));
1847 DebugSetProcessKillOnExit (FALSE
);
1851 char *exec_file
= (char *) get_exec_file (0);
1854 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1855 target_pid_to_str (pid_to_ptid (pid
)));
1857 printf_unfiltered ("Attaching to %s\n",
1858 target_pid_to_str (pid_to_ptid (pid
)));
1860 gdb_flush (gdb_stdout
);
1863 do_initial_windows_stuff (ops
, pid
, 1);
1864 target_terminal_ours ();
1868 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1873 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1875 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1877 error (_("Can't detach process %u (error %u)"),
1878 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1881 DebugSetProcessKillOnExit (FALSE
);
1883 if (detached
&& from_tty
)
1885 char *exec_file
= get_exec_file (0);
1888 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1889 (unsigned) current_event
.dwProcessId
);
1890 gdb_flush (gdb_stdout
);
1893 i386_cleanup_dregs ();
1894 inferior_ptid
= null_ptid
;
1895 detach_inferior (current_event
.dwProcessId
);
1897 unpush_target (ops
);
1901 windows_pid_to_exec_file (int pid
)
1903 static char path
[__PMAX
];
1905 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1907 char procexe
[sizeof ("/proc/4294967295/exe")];
1909 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1910 nchars
= readlink (procexe
, path
, sizeof(path
));
1911 if (nchars
> 0 && nchars
< sizeof (path
))
1913 path
[nchars
] = '\0'; /* Got it */
1918 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1919 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1920 if (!get_module_name (0, path
))
1926 /* Print status information about what we're accessing. */
1929 windows_files_info (struct target_ops
*ignore
)
1931 struct inferior
*inf
= current_inferior ();
1933 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1934 inf
->attach_flag
? "attached" : "child",
1935 target_pid_to_str (inferior_ptid
));
1939 windows_open (char *arg
, int from_tty
)
1941 error (_("Use the \"run\" command to start a Unix child process."));
1944 /* Modify CreateProcess parameters for use of a new separate console.
1946 *FLAGS: DWORD parameter for general process creation flags.
1947 *SI: STARTUPINFO structure, for which the console window size and
1948 console buffer size is filled in if GDB is running in a console.
1949 to create the new console.
1950 The size of the used font is not available on all versions of
1951 Windows OS. Furthermore, the current font might not be the default
1952 font, but this is still better than before.
1953 If the windows and buffer sizes are computed,
1954 SI->DWFLAGS is changed so that this information is used
1955 by CreateProcess function. */
1958 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1960 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1961 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1963 if (hconsole
!= INVALID_HANDLE_VALUE
)
1965 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1967 CONSOLE_FONT_INFO cfi
;
1969 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1970 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1971 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1972 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1973 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1975 si
->dwXSize
*= font_size
.X
;
1979 si
->dwYSize
*= font_size
.Y
;
1982 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1983 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1984 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1986 *flags
|= CREATE_NEW_CONSOLE
;
1990 /* Function called by qsort to sort environment strings. */
1993 envvar_cmp (const void *a
, const void *b
)
1995 const char **p
= (const char **) a
;
1996 const char **q
= (const char **) b
;
1997 return strcasecmp (*p
, *q
);
2003 clear_win32_environment (char **env
)
2007 wchar_t *copy
= NULL
, *equalpos
;
2009 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2011 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2012 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2013 mbstowcs (copy
, env
[i
], len
);
2014 equalpos
= wcschr (copy
, L
'=');
2017 SetEnvironmentVariableW (copy
, NULL
);
2023 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2024 EXEC_FILE is the file to run.
2025 ALLARGS is a string containing the arguments to the program.
2026 ENV is the environment vector to pass. Errors reported with error(). */
2029 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2030 char *allargs
, char **in_env
, int from_tty
)
2034 cygwin_buf_t real_path
[__PMAX
];
2035 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2037 cygwin_buf_t
*toexec
;
2038 cygwin_buf_t
*cygallargs
;
2040 char **old_env
= NULL
;
2044 int ostdin
, ostdout
, ostderr
;
2046 char real_path
[__PMAX
];
2047 char shell
[__PMAX
]; /* Path to shell */
2059 PROCESS_INFORMATION pi
;
2062 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2065 error (_("No executable specified, use `target exec'."));
2067 memset (&si
, 0, sizeof (si
));
2068 si
.cb
= sizeof (si
);
2071 flags
|= CREATE_NEW_PROCESS_GROUP
;
2074 windows_set_console_info (&si
, &flags
);
2079 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2080 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2081 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2082 error (_("Error starting executable: %d"), errno
);
2085 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2086 if (len
== (size_t) -1)
2087 error (_("Error starting executable: %d"), errno
);
2088 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2089 mbstowcs (cygallargs
, allargs
, len
);
2091 cygallargs
= allargs
;
2096 sh
= getenv ("SHELL");
2099 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2100 error (_("Error starting executable via shell: %d"), errno
);
2102 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2103 + mbstowcs (NULL
, allargs
, 0) + 2;
2104 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2105 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2107 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2108 + strlen (allargs
) + 2);
2109 cygallargs
= (char *) alloca (len
);
2110 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2113 flags
|= DEBUG_PROCESS
;
2117 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2118 * sizeof (wchar_t));
2119 wcscpy (args
, toexec
);
2120 wcscat (args
, L
" ");
2121 wcscat (args
, cygallargs
);
2123 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2124 strcpy (args
, toexec
);
2126 strcat (args
, cygallargs
);
2129 #ifdef CW_CVT_ENV_TO_WINENV
2130 /* First try to create a direct Win32 copy of the POSIX environment. */
2131 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2132 if (w32_env
!= (PWCHAR
) -1)
2133 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2135 /* If that fails, fall back to old method tweaking GDB's environment. */
2138 /* Reset all Win32 environment variables to avoid leftover on next run. */
2139 clear_win32_environment (environ
);
2140 /* Prepare the environment vars for CreateProcess. */
2143 cygwin_internal (CW_SYNC_WINENV
);
2147 if (!inferior_io_terminal
)
2148 tty
= ostdin
= ostdout
= ostderr
= -1;
2151 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2154 print_sys_errmsg (inferior_io_terminal
, errno
);
2155 ostdin
= ostdout
= ostderr
= -1;
2168 windows_init_thread_list ();
2169 ret
= CreateProcess (0,
2170 args
, /* command line */
2171 NULL
, /* Security */
2173 TRUE
, /* inherit handles */
2174 flags
, /* start flags */
2175 w32_env
, /* environment */
2176 NULL
, /* current directory */
2180 /* Just free the Win32 environment, if it could be created. */
2184 /* Reset all environment variables to avoid leftover on next run. */
2185 clear_win32_environment (in_env
);
2186 /* Restore normal GDB environment variables. */
2188 cygwin_internal (CW_SYNC_WINENV
);
2203 /* Build the command line, a space-separated list of tokens where
2204 the first token is the name of the module to be executed.
2205 To avoid ambiguities introduced by spaces in the module name,
2207 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2208 args
= alloca (args_len
);
2209 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2211 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2213 if (!inferior_io_terminal
)
2214 tty
= INVALID_HANDLE_VALUE
;
2217 SECURITY_ATTRIBUTES sa
;
2218 sa
.nLength
= sizeof(sa
);
2219 sa
.lpSecurityDescriptor
= 0;
2220 sa
.bInheritHandle
= TRUE
;
2221 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2222 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2223 if (tty
== INVALID_HANDLE_VALUE
)
2224 warning (_("Warning: Failed to open TTY %s, error %#x."),
2225 inferior_io_terminal
, (unsigned) GetLastError ());
2229 si
.hStdOutput
= tty
;
2231 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2235 /* CreateProcess takes the environment list as a null terminated set of
2236 strings (i.e. two nulls terminate the list). */
2238 /* Get total size for env strings. */
2239 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2240 envlen
+= strlen (in_env
[i
]) + 1;
2242 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2243 env
= (char **) alloca (envsize
);
2244 memcpy (env
, in_env
, envsize
);
2245 /* Windows programs expect the environment block to be sorted. */
2246 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2248 w32env
= alloca (envlen
+ 1);
2250 /* Copy env strings into new buffer. */
2251 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2253 strcpy (temp
, env
[i
]);
2254 temp
+= strlen (temp
) + 1;
2257 /* Final nil string to terminate new env. */
2260 windows_init_thread_list ();
2261 ret
= CreateProcessA (0,
2262 args
, /* command line */
2263 NULL
, /* Security */
2265 TRUE
, /* inherit handles */
2266 flags
, /* start flags */
2267 w32env
, /* environment */
2268 NULL
, /* current directory */
2271 if (tty
!= INVALID_HANDLE_VALUE
)
2276 error (_("Error creating process %s, (error %u)."),
2277 exec_file
, (unsigned) GetLastError ());
2279 CloseHandle (pi
.hThread
);
2280 CloseHandle (pi
.hProcess
);
2282 if (useshell
&& shell
[0] != '\0')
2287 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2289 /* windows_continue (DBG_CONTINUE, -1); */
2293 windows_mourn_inferior (struct target_ops
*ops
)
2295 (void) windows_continue (DBG_CONTINUE
, -1);
2296 i386_cleanup_dregs();
2297 if (open_process_used
)
2299 CHECK (CloseHandle (current_process_handle
));
2300 open_process_used
= 0;
2302 unpush_target (ops
);
2303 generic_mourn_inferior ();
2306 /* Send a SIGINT to the process group. This acts just like the user typed a
2307 ^C on the controlling terminal. */
2310 windows_stop (ptid_t ptid
)
2312 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2313 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2314 registers_changed (); /* refresh register state */
2318 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2319 int write
, struct mem_attrib
*mem
,
2320 struct target_ops
*target
)
2325 DEBUG_MEM (("gdb: write target memory, %d bytes at %s\n",
2326 len
, core_addr_to_string (memaddr
)));
2327 if (!WriteProcessMemory (current_process_handle
,
2328 (LPVOID
) (uintptr_t) memaddr
, our
,
2331 FlushInstructionCache (current_process_handle
,
2332 (LPCVOID
) (uintptr_t) memaddr
, len
);
2336 DEBUG_MEM (("gdb: read target memory, %d bytes at %s\n",
2337 len
, core_addr_to_string (memaddr
)));
2338 if (!ReadProcessMemory (current_process_handle
,
2339 (LPCVOID
) (uintptr_t) memaddr
, our
,
2347 windows_kill_inferior (struct target_ops
*ops
)
2349 CHECK (TerminateProcess (current_process_handle
, 0));
2353 if (!windows_continue (DBG_CONTINUE
, -1))
2355 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2357 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2361 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2365 windows_prepare_to_store (struct regcache
*regcache
)
2367 /* Do nothing, since we can store individual regs. */
2371 windows_can_run (void)
2377 windows_close (void)
2379 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2380 PIDGET (inferior_ptid
)));
2383 /* Convert pid to printable format. */
2385 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2387 static char buf
[80];
2389 if (ptid_get_tid (ptid
) != 0)
2391 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2392 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2396 return normal_pid_to_str (ptid
);
2400 windows_xfer_shared_libraries (struct target_ops
*ops
,
2401 enum target_object object
, const char *annex
,
2402 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2403 ULONGEST offset
, LONGEST len
)
2405 struct obstack obstack
;
2413 obstack_init (&obstack
);
2414 obstack_grow_str (&obstack
, "<library-list>\n");
2415 for (so
= solib_start
.next
; so
; so
= so
->next
)
2416 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2417 (uintptr_t) so
->lm_info
->load_addr
,
2418 target_gdbarch (), &obstack
);
2419 obstack_grow_str0 (&obstack
, "</library-list>\n");
2421 buf
= obstack_finish (&obstack
);
2422 len_avail
= strlen (buf
);
2423 if (offset
>= len_avail
)
2427 if (len
> len_avail
- offset
)
2428 len
= len_avail
- offset
;
2429 memcpy (readbuf
, buf
+ offset
, len
);
2432 obstack_free (&obstack
, NULL
);
2437 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2438 const char *annex
, gdb_byte
*readbuf
,
2439 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2443 case TARGET_OBJECT_MEMORY
:
2445 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2446 len
, 0/*read*/, NULL
, ops
);
2448 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2449 len
, 1/*write*/, NULL
, ops
);
2452 case TARGET_OBJECT_LIBRARIES
:
2453 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2454 writebuf
, offset
, len
);
2457 if (ops
->beneath
!= NULL
)
2458 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2459 readbuf
, writebuf
, offset
, len
);
2464 /* Provide thread local base, i.e. Thread Information Block address.
2465 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2468 windows_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2472 th
= thread_rec (ptid_get_tid (ptid
), 0);
2477 *addr
= th
->thread_local_base
;
2483 windows_get_ada_task_ptid (long lwp
, long thread
)
2485 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2489 init_windows_ops (void)
2491 windows_ops
.to_shortname
= "child";
2492 windows_ops
.to_longname
= "Win32 child process";
2493 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2494 windows_ops
.to_open
= windows_open
;
2495 windows_ops
.to_close
= windows_close
;
2496 windows_ops
.to_attach
= windows_attach
;
2497 windows_ops
.to_attach_no_wait
= 1;
2498 windows_ops
.to_detach
= windows_detach
;
2499 windows_ops
.to_resume
= windows_resume
;
2500 windows_ops
.to_wait
= windows_wait
;
2501 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2502 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2503 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2504 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2505 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2506 windows_ops
.to_files_info
= windows_files_info
;
2507 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2508 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2509 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2510 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2511 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2512 windows_ops
.to_terminal_ours
= terminal_ours
;
2513 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2514 windows_ops
.to_terminal_info
= child_terminal_info
;
2515 windows_ops
.to_kill
= windows_kill_inferior
;
2516 windows_ops
.to_create_inferior
= windows_create_inferior
;
2517 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2518 windows_ops
.to_can_run
= windows_can_run
;
2519 windows_ops
.to_thread_alive
= windows_thread_alive
;
2520 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2521 windows_ops
.to_stop
= windows_stop
;
2522 windows_ops
.to_stratum
= process_stratum
;
2523 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2524 windows_ops
.to_has_memory
= default_child_has_memory
;
2525 windows_ops
.to_has_stack
= default_child_has_stack
;
2526 windows_ops
.to_has_registers
= default_child_has_registers
;
2527 windows_ops
.to_has_execution
= default_child_has_execution
;
2528 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2529 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2530 windows_ops
.to_get_tib_address
= windows_get_tib_address
;
2532 i386_use_watchpoints (&windows_ops
);
2534 i386_dr_low
.set_control
= cygwin_set_dr7
;
2535 i386_dr_low
.set_addr
= cygwin_set_dr
;
2536 i386_dr_low
.get_addr
= cygwin_get_dr
;
2537 i386_dr_low
.get_status
= cygwin_get_dr6
;
2538 i386_dr_low
.get_control
= cygwin_get_dr7
;
2540 /* i386_dr_low.debug_register_length field is set by
2541 calling i386_set_debug_register_length function
2542 in processor windows specific native file. */
2544 windows_ops
.to_magic
= OPS_MAGIC
;
2548 set_windows_aliases (char *argv0
)
2550 add_info_alias ("dll", "sharedlibrary", 1);
2553 /* -Wmissing-prototypes */
2554 extern initialize_file_ftype _initialize_windows_nat
;
2557 _initialize_windows_nat (void)
2559 struct cmd_list_element
*c
;
2561 init_windows_ops ();
2564 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2567 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2568 _("Load dll library symbols from FILE."));
2569 set_cmd_completer (c
, filename_completer
);
2571 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2573 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2575 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2578 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2579 Set use of shell to start subprocess."), _("\
2580 Show use of shell to start subprocess."), NULL
,
2582 NULL
, /* FIXME: i18n: */
2583 &setlist
, &showlist
);
2585 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2586 &cygwin_exceptions
, _("\
2587 Break when an exception is detected in the Cygwin DLL itself."), _("\
2588 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2590 NULL
, /* FIXME: i18n: */
2591 &setlist
, &showlist
);
2594 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2595 Set creation of new console when creating child process."), _("\
2596 Show creation of new console when creating child process."), NULL
,
2598 NULL
, /* FIXME: i18n: */
2599 &setlist
, &showlist
);
2601 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2602 Set creation of new group when creating child process."), _("\
2603 Show creation of new group when creating child process."), NULL
,
2605 NULL
, /* FIXME: i18n: */
2606 &setlist
, &showlist
);
2608 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2609 Set whether to display execution in child process."), _("\
2610 Show whether to display execution in child process."), NULL
,
2612 NULL
, /* FIXME: i18n: */
2613 &setlist
, &showlist
);
2615 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2616 Set whether to display kernel events in child process."), _("\
2617 Show whether to display kernel events in child process."), NULL
,
2619 NULL
, /* FIXME: i18n: */
2620 &setlist
, &showlist
);
2622 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2623 Set whether to display memory accesses in child process."), _("\
2624 Show whether to display memory accesses in child process."), NULL
,
2626 NULL
, /* FIXME: i18n: */
2627 &setlist
, &showlist
);
2629 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2630 &debug_exceptions
, _("\
2631 Set whether to display kernel exceptions in child process."), _("\
2632 Show whether to display kernel exceptions in child process."), NULL
,
2634 NULL
, /* FIXME: i18n: */
2635 &setlist
, &showlist
);
2637 init_w32_command_list ();
2639 add_cmd ("selector", class_info
, display_selectors
,
2640 _("Display selectors infos."),
2642 add_target (&windows_ops
);
2643 deprecated_init_ui_hook
= set_windows_aliases
;
2646 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2648 /* Pass the address ADDR to the inferior in the I'th debug register.
2649 Here we just store the address in dr array, the registers will be
2650 actually set up when windows_continue is called. */
2652 cygwin_set_dr (int i
, CORE_ADDR addr
)
2655 internal_error (__FILE__
, __LINE__
,
2656 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2658 debug_registers_changed
= 1;
2659 debug_registers_used
= 1;
2662 /* Pass the value VAL to the inferior in the DR7 debug control
2663 register. Here we just store the address in D_REGS, the watchpoint
2664 will be actually set up in windows_wait. */
2666 cygwin_set_dr7 (unsigned long val
)
2668 dr
[7] = (CORE_ADDR
) val
;
2669 debug_registers_changed
= 1;
2670 debug_registers_used
= 1;
2673 /* Get the value of debug register I from the inferior. */
2676 cygwin_get_dr (int i
)
2681 /* Get the value of the DR6 debug status register from the inferior.
2682 Here we just return the value stored in dr[6]
2683 by the last call to thread_rec for current_event.dwThreadId id. */
2684 static unsigned long
2685 cygwin_get_dr6 (void)
2687 return (unsigned long) dr
[6];
2690 /* Get the value of the DR7 debug status register from the inferior.
2691 Here we just return the value stored in dr[7] by the last call to
2692 thread_rec for current_event.dwThreadId id. */
2694 static unsigned long
2695 cygwin_get_dr7 (void)
2697 return (unsigned long) dr
[7];
2700 /* Determine if the thread referenced by "ptid" is alive
2701 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2702 it means that the thread has died. Otherwise it is assumed to be alive. */
2704 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2708 gdb_assert (ptid_get_tid (ptid
) != 0);
2709 tid
= ptid_get_tid (ptid
);
2711 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2715 /* -Wmissing-prototypes */
2716 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2719 _initialize_check_for_gdb_ini (void)
2722 if (inhibit_gdbinit
)
2725 homedir
= getenv ("HOME");
2729 char *oldini
= (char *) alloca (strlen (homedir
) +
2730 sizeof ("/gdb.ini"));
2731 strcpy (oldini
, homedir
);
2732 p
= strchr (oldini
, '\0');
2733 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2735 strcpy (p
, "gdb.ini");
2736 if (access (oldini
, 0) == 0)
2738 int len
= strlen (oldini
);
2739 char *newini
= alloca (len
+ 1);
2741 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2742 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2743 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2748 /* Define dummy functions which always return error for the rare cases where
2749 these functions could not be found. */
2751 bad_DebugActiveProcessStop (DWORD w
)
2756 bad_DebugBreakProcess (HANDLE w
)
2761 bad_DebugSetProcessKillOnExit (BOOL w
)
2766 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2773 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2779 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2786 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2792 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2798 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2804 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2812 /* -Wmissing-prototypes */
2813 extern initialize_file_ftype _initialize_loadable
;
2815 /* Load any functions which may not be available in ancient versions
2819 _initialize_loadable (void)
2823 hm
= LoadLibrary ("kernel32.dll");
2826 DebugActiveProcessStop
= (void *)
2827 GetProcAddress (hm
, "DebugActiveProcessStop");
2828 DebugBreakProcess
= (void *)
2829 GetProcAddress (hm
, "DebugBreakProcess");
2830 DebugSetProcessKillOnExit
= (void *)
2831 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2832 GetConsoleFontSize
= (void *)
2833 GetProcAddress (hm
, "GetConsoleFontSize");
2834 GetCurrentConsoleFont
= (void *)
2835 GetProcAddress (hm
, "GetCurrentConsoleFont");
2838 /* Set variables to dummy versions of these processes if the function
2839 wasn't found in kernel32.dll. */
2840 if (!DebugBreakProcess
)
2841 DebugBreakProcess
= bad_DebugBreakProcess
;
2842 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2844 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2845 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2847 if (!GetConsoleFontSize
)
2848 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2849 if (!GetCurrentConsoleFont
)
2850 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2852 /* Load optional functions used for retrieving filename information
2853 associated with the currently debugged process or its dlls. */
2854 hm
= LoadLibrary ("psapi.dll");
2857 EnumProcessModules
= (void *)
2858 GetProcAddress (hm
, "EnumProcessModules");
2859 GetModuleInformation
= (void *)
2860 GetProcAddress (hm
, "GetModuleInformation");
2861 GetModuleFileNameEx
= (void *)
2862 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2865 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2867 /* Set variables to dummy versions of these processes if the function
2868 wasn't found in psapi.dll. */
2869 EnumProcessModules
= bad_EnumProcessModules
;
2870 GetModuleInformation
= bad_GetModuleInformation
;
2871 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2872 /* This will probably fail on Windows 9x/Me. Let the user know
2873 that we're missing some functionality. */
2875 cannot automatically find executable file or library to read symbols.\n\
2876 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2879 hm
= LoadLibrary ("advapi32.dll");
2882 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2883 LookupPrivilegeValueA
= (void *)
2884 GetProcAddress (hm
, "LookupPrivilegeValueA");
2885 AdjustTokenPrivileges
= (void *)
2886 GetProcAddress (hm
, "AdjustTokenPrivileges");
2887 /* Only need to set one of these since if OpenProcessToken fails nothing
2889 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2890 || !AdjustTokenPrivileges
)
2891 OpenProcessToken
= bad_OpenProcessToken
;