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 ();
315 warning (_("SuspendThread (tid=0x%x) failed."
317 (unsigned) id
, (unsigned) err
);
322 else if (get_context
< 0)
324 th
->reload_context
= 1;
332 /* Add a thread to the thread list. */
334 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
339 gdb_assert (ptid_get_tid (ptid
) != 0);
341 id
= ptid_get_tid (ptid
);
343 if ((th
= thread_rec (id
, FALSE
)))
346 th
= XZALLOC (thread_info
);
349 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
350 th
->next
= thread_head
.next
;
351 thread_head
.next
= th
;
353 /* Set the debug registers for the new thread if they are used. */
354 if (debug_registers_used
)
356 /* Only change the value of the debug registers. */
357 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
358 CHECK (GetThreadContext (th
->h
, &th
->context
));
359 th
->context
.Dr0
= dr
[0];
360 th
->context
.Dr1
= dr
[1];
361 th
->context
.Dr2
= dr
[2];
362 th
->context
.Dr3
= dr
[3];
363 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
364 th
->context
.Dr7
= dr
[7];
365 CHECK (SetThreadContext (th
->h
, &th
->context
));
366 th
->context
.ContextFlags
= 0;
371 /* Clear out any old thread list and reintialize it to a
374 windows_init_thread_list (void)
376 thread_info
*th
= &thread_head
;
378 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
380 while (th
->next
!= NULL
)
382 thread_info
*here
= th
->next
;
383 th
->next
= here
->next
;
386 thread_head
.next
= NULL
;
389 /* Delete a thread from the list of threads. */
391 windows_delete_thread (ptid_t ptid
, DWORD exit_code
)
396 gdb_assert (ptid_get_tid (ptid
) != 0);
398 id
= ptid_get_tid (ptid
);
401 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
402 else if (print_thread_events
&& id
!= main_thread_id
)
403 printf_unfiltered (_("[%s exited with code %u]\n"),
404 target_pid_to_str (ptid
), (unsigned) exit_code
);
405 delete_thread (ptid
);
407 for (th
= &thread_head
;
408 th
->next
!= NULL
&& th
->next
->id
!= id
;
412 if (th
->next
!= NULL
)
414 thread_info
*here
= th
->next
;
415 th
->next
= here
->next
;
421 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
423 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
424 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
425 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
429 return; /* Windows sometimes uses a non-existent thread id in its
432 if (current_thread
->reload_context
)
434 #ifdef __COPY_CONTEXT_SIZE
435 if (have_saved_context
)
437 /* Lie about where the program actually is stopped since
438 cygwin has informed us that we should consider the signal
439 to have occurred at another location which is stored in
441 memcpy (¤t_thread
->context
, &saved_context
,
442 __COPY_CONTEXT_SIZE
);
443 have_saved_context
= 0;
448 thread_info
*th
= current_thread
;
449 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
450 GetThreadContext (th
->h
, &th
->context
);
451 /* Copy dr values from that thread.
452 But only if there were not modified since last stop.
454 if (!debug_registers_changed
)
456 dr
[0] = th
->context
.Dr0
;
457 dr
[1] = th
->context
.Dr1
;
458 dr
[2] = th
->context
.Dr2
;
459 dr
[3] = th
->context
.Dr3
;
460 dr
[6] = th
->context
.Dr6
;
461 dr
[7] = th
->context
.Dr7
;
464 current_thread
->reload_context
= 0;
467 if (r
== I387_FISEG_REGNUM (tdep
))
469 l
= *((long *) context_offset
) & 0xffff;
470 regcache_raw_supply (regcache
, r
, (char *) &l
);
472 else if (r
== I387_FOP_REGNUM (tdep
))
474 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
475 regcache_raw_supply (regcache
, r
, (char *) &l
);
477 else if (segment_register_p (r
))
479 /* GDB treats segment registers as 32bit registers, but they are
480 in fact only 16 bits long. Make sure we do not read extra
481 bits from our source buffer. */
482 l
= *((long *) context_offset
) & 0xffff;
483 regcache_raw_supply (regcache
, r
, (char *) &l
);
486 regcache_raw_supply (regcache
, r
, context_offset
);
489 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
490 do_windows_fetch_inferior_registers (regcache
, r
);
495 windows_fetch_inferior_registers (struct target_ops
*ops
,
496 struct regcache
*regcache
, int r
)
498 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
499 /* Check if current_thread exists. Windows sometimes uses a non-existent
500 thread id in its events. */
502 do_windows_fetch_inferior_registers (regcache
, r
);
506 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
509 /* Windows sometimes uses a non-existent thread id in its events. */;
511 regcache_raw_collect (regcache
, r
,
512 ((char *) ¤t_thread
->context
) + mappings
[r
]);
515 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
516 do_windows_store_inferior_registers (regcache
, r
);
520 /* Store a new register value into the current thread context. */
522 windows_store_inferior_registers (struct target_ops
*ops
,
523 struct regcache
*regcache
, int r
)
525 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
526 /* Check if current_thread exists. Windows sometimes uses a non-existent
527 thread id in its events. */
529 do_windows_store_inferior_registers (regcache
, r
);
532 /* Get the name of a given module at given base address. If base_address
533 is zero return the first loaded module (which is always the name of the
536 get_module_name (LPVOID base_address
, char *dll_name_ret
)
542 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for
546 cygwin_buf_t pathbuf
[__PMAX
]; /* Temporary storage prior to converting to
547 posix form. __PMAX is always enough
548 as long as SO_NAME_MAX_PATH_SIZE is defined
553 /* Find size of buffer needed to handle list of modules loaded in
555 if (!EnumProcessModules (current_process_handle
, DllHandle
,
556 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
559 /* Allocate correct amount of space for module list. */
560 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
564 /* Get the list of modules. */
565 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
569 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
571 /* Get information on this module. */
572 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
574 error (_("Can't get module info"));
576 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
578 /* Try to find the name of the given module. */
580 /* Cygwin prefers that the path be in /x/y/z format. */
581 len
= GetModuleFileNameEx (current_process_handle
,
582 DllHandle
[i
], pathbuf
, __PMAX
);
584 error (_("Error getting dll name: %u."),
585 (unsigned) GetLastError ());
586 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
588 error (_("Error converting dll name to POSIX: %d."), errno
);
590 len
= GetModuleFileNameEx (current_process_handle
,
591 DllHandle
[i
], dll_name_ret
, __PMAX
);
593 error (_("Error getting dll name: %u."),
594 (unsigned) GetLastError ());
596 return 1; /* success */
601 dll_name_ret
[0] = '\0';
602 return 0; /* failure */
605 /* Encapsulate the information required in a call to
606 symbol_file_add_args. */
607 struct safe_symbol_file_add_args
611 struct section_addr_info
*addrs
;
614 struct ui_file
*err
, *out
;
618 /* Maintain a linked list of "so" information. */
624 static struct so_list solib_start
, *solib_end
;
626 /* Call symbol_file_add with stderr redirected. We don't care if there
629 safe_symbol_file_add_stub (void *argv
)
631 #define p ((struct safe_symbol_file_add_args *) argv)
632 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
633 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
634 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
639 /* Restore gdb's stderr after calling symbol_file_add. */
641 safe_symbol_file_add_cleanup (void *p
)
643 #define sp ((struct safe_symbol_file_add_args *)p)
644 gdb_flush (gdb_stderr
);
645 gdb_flush (gdb_stdout
);
646 ui_file_delete (gdb_stderr
);
647 ui_file_delete (gdb_stdout
);
648 gdb_stderr
= sp
->err
;
649 gdb_stdout
= sp
->out
;
653 /* symbol_file_add wrapper that prevents errors from being displayed. */
654 static struct objfile
*
655 safe_symbol_file_add (char *name
, int from_tty
,
656 struct section_addr_info
*addrs
,
657 int mainline
, int flags
)
659 struct safe_symbol_file_add_args p
;
660 struct cleanup
*cleanup
;
662 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
666 gdb_flush (gdb_stderr
);
667 gdb_flush (gdb_stdout
);
668 gdb_stderr
= ui_file_new ();
669 gdb_stdout
= ui_file_new ();
671 p
.from_tty
= from_tty
;
673 p
.mainline
= mainline
;
675 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
677 do_cleanups (cleanup
);
681 static struct so_list
*
682 windows_make_so (const char *name
, LPVOID load_addr
)
689 WIN32_FIND_DATA w32_fd
;
690 HANDLE h
= FindFirstFile(name
, &w32_fd
);
692 if (h
== INVALID_HANDLE_VALUE
)
698 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
700 p
= strrchr (buf
, '\\');
703 SetCurrentDirectory (buf
);
704 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
705 SetCurrentDirectory (cwd
);
708 if (strcasecmp (buf
, "ntdll.dll") == 0)
710 GetSystemDirectory (buf
, sizeof (buf
));
711 strcat (buf
, "\\ntdll.dll");
714 cygwin_buf_t buf
[__PMAX
];
717 if (access (name
, F_OK
) != 0)
719 if (strcasecmp (name
, "ntdll.dll") == 0)
722 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
723 wcscat (buf
, L
"\\ntdll.dll");
727 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
728 strcat (buf
, "\\ntdll.dll");
733 so
= XZALLOC (struct so_list
);
734 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
735 so
->lm_info
->load_addr
= load_addr
;
736 strcpy (so
->so_original_name
, name
);
738 strcpy (so
->so_name
, buf
);
741 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
742 SO_NAME_MAX_PATH_SIZE
);
745 char *rname
= realpath (name
, NULL
);
746 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
748 strcpy (so
->so_name
, rname
);
752 error (_("dll path too long"));
754 /* Record cygwin1.dll .text start/end. */
755 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
756 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
759 asection
*text
= NULL
;
762 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
767 if (bfd_check_format (abfd
, bfd_object
))
768 text
= bfd_get_section_by_name (abfd
, ".text");
772 gdb_bfd_unref (abfd
);
776 /* The symbols in a dll are offset by 0x1000, which is the
777 offset from 0 of the first byte in an image - because of the
778 file header and the section alignment. */
779 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
781 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
783 gdb_bfd_unref (abfd
);
791 get_image_name (HANDLE h
, void *address
, int unicode
)
794 static char buf
[__PMAX
];
796 static char buf
[(2 * __PMAX
) + 1];
798 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
804 /* Attempt to read the name of the dll that was detected.
805 This is documented to work only when actively debugging
806 a program. It will not work for attached processes. */
810 /* See if we could read the address of a string, and that the
811 address isn't null. */
812 if (!ReadProcessMemory (h
, address
, &address_ptr
,
813 sizeof (address_ptr
), &done
)
814 || done
!= sizeof (address_ptr
) || !address_ptr
)
817 /* Find the length of the string. */
818 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
819 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
823 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
826 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
827 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
830 wcstombs (buf
, unicode_address
, __PMAX
);
832 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
840 /* Wait for child to do something. Return pid of child, or -1 in case
841 of error; store status through argument pointer OURSTATUS. */
843 handle_load_dll (void *dummy
)
845 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
846 char dll_buf
[__PMAX
];
847 char *dll_name
= NULL
;
849 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
851 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
852 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
856 if (*dll_name
== '\0')
857 dll_name
= get_image_name (current_process_handle
,
858 event
->lpImageName
, event
->fUnicode
);
862 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
863 solib_end
= solib_end
->next
;
865 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
866 host_address_to_string (solib_end
->lm_info
->load_addr
)));
872 windows_free_so (struct so_list
*so
)
880 handle_unload_dll (void *dummy
)
882 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
885 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
886 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
888 struct so_list
*sodel
= so
->next
;
890 so
->next
= sodel
->next
;
893 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
895 windows_free_so (sodel
);
899 /* We did not find any DLL that was previously loaded at this address,
900 so register a complaint. We do not report an error, because we have
901 observed that this may be happening under some circumstances. For
902 instance, running 32bit applications on x64 Windows causes us to receive
903 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
904 events are apparently caused by the WOW layer, the interface between
905 32bit and 64bit worlds). */
906 complaint (&symfile_complaints
, _("dll starting at %s not found."),
907 host_address_to_string (lpBaseOfDll
));
912 /* Clear list of loaded DLLs. */
914 windows_clear_solib (void)
916 solib_start
.next
= NULL
;
917 solib_end
= &solib_start
;
920 /* Load DLL symbol info. */
922 dll_symbol_command (char *args
, int from_tty
)
928 error (_("dll-symbols requires a file name"));
931 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
933 char *newargs
= (char *) alloca (n
+ 4 + 1);
934 strcpy (newargs
, args
);
935 strcat (newargs
, ".dll");
939 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
942 /* Handle DEBUG_STRING output from child process.
943 Cygwin prepends its messages with a "cygwin:". Interpret this as
944 a Cygwin signal. Otherwise just print the string as a warning. */
946 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
951 if (!target_read_string
952 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
956 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
957 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
960 if (strncmp (s
, "cYg", 3) != 0)
964 #ifdef __COPY_CONTEXT_SIZE
967 /* Got a cygwin signal marker. A cygwin signal is followed by
968 the signal number itself and then optionally followed by the
969 thread id and address to saved context within the DLL. If
970 these are supplied, then the given thread is assumed to have
971 issued the signal and the context from the thread is assumed
972 to be stored at the given address in the inferior. Tell gdb
973 to treat this like a real signal. */
975 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
976 int gotasig
= gdb_signal_from_host (sig
);
978 ourstatus
->value
.sig
= gotasig
;
984 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
985 retval
= strtoul (p
, &p
, 0);
987 retval
= main_thread_id
;
988 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
989 && ReadProcessMemory (current_process_handle
, x
,
991 __COPY_CONTEXT_SIZE
, &n
)
992 && n
== __COPY_CONTEXT_SIZE
)
993 have_saved_context
= 1;
994 current_event
.dwThreadId
= retval
;
1005 display_selector (HANDLE thread
, DWORD sel
)
1008 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1011 printf_filtered ("0x%03x: ", (unsigned) sel
);
1012 if (!info
.HighWord
.Bits
.Pres
)
1014 puts_filtered ("Segment not present\n");
1017 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1018 (info
.HighWord
.Bits
.BaseMid
<< 16)
1020 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1021 if (info
.HighWord
.Bits
.Granularity
)
1022 limit
= (limit
<< 12) | 0xfff;
1023 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1024 if (info
.HighWord
.Bits
.Default_Big
)
1025 puts_filtered(" 32-bit ");
1027 puts_filtered(" 16-bit ");
1028 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1031 puts_filtered ("Data (Read-Only, Exp-up");
1034 puts_filtered ("Data (Read/Write, Exp-up");
1037 puts_filtered ("Unused segment (");
1040 puts_filtered ("Data (Read/Write, Exp-down");
1043 puts_filtered ("Code (Exec-Only, N.Conf");
1046 puts_filtered ("Code (Exec/Read, N.Conf");
1049 puts_filtered ("Code (Exec-Only, Conf");
1052 puts_filtered ("Code (Exec/Read, Conf");
1055 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1057 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1058 puts_filtered(", N.Acc");
1059 puts_filtered (")\n");
1060 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1061 puts_filtered("System selector ");
1062 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1063 if (info
.HighWord
.Bits
.Granularity
)
1064 puts_filtered ("Page granular.\n");
1066 puts_filtered ("Byte granular.\n");
1071 DWORD err
= GetLastError ();
1072 if (err
== ERROR_NOT_SUPPORTED
)
1073 printf_filtered ("Function not supported\n");
1075 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1081 display_selectors (char * args
, int from_tty
)
1083 if (!current_thread
)
1085 puts_filtered ("Impossible to display selectors now.\n");
1091 puts_filtered ("Selector $cs\n");
1092 display_selector (current_thread
->h
,
1093 current_thread
->context
.SegCs
);
1094 puts_filtered ("Selector $ds\n");
1095 display_selector (current_thread
->h
,
1096 current_thread
->context
.SegDs
);
1097 puts_filtered ("Selector $es\n");
1098 display_selector (current_thread
->h
,
1099 current_thread
->context
.SegEs
);
1100 puts_filtered ("Selector $ss\n");
1101 display_selector (current_thread
->h
,
1102 current_thread
->context
.SegSs
);
1103 puts_filtered ("Selector $fs\n");
1104 display_selector (current_thread
->h
,
1105 current_thread
->context
.SegFs
);
1106 puts_filtered ("Selector $gs\n");
1107 display_selector (current_thread
->h
,
1108 current_thread
->context
.SegGs
);
1113 sel
= parse_and_eval_long (args
);
1114 printf_filtered ("Selector \"%s\"\n",args
);
1115 display_selector (current_thread
->h
, sel
);
1119 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1120 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1121 host_address_to_string (\
1122 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1125 handle_exception (struct target_waitstatus
*ourstatus
)
1128 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1130 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1132 /* Record the context of the current thread. */
1133 th
= thread_rec (current_event
.dwThreadId
, -1);
1137 case EXCEPTION_ACCESS_VIOLATION
:
1138 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1139 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1142 /* See if the access violation happened within the cygwin DLL
1143 itself. Cygwin uses a kind of exception handling to deal
1144 with passed-in invalid addresses. gdb should not treat
1145 these as real SEGVs since they will be silently handled by
1146 cygwin. A real SEGV will (theoretically) be caught by
1147 cygwin later in the process and will be sent as a
1148 cygwin-specific-signal. So, ignore SEGVs if they show up
1149 within the text segment of the DLL itself. */
1151 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1152 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1154 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1155 && addr
< cygwin_load_end
))
1156 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1157 && strncmp (fn
, "KERNEL32!IsBad",
1158 strlen ("KERNEL32!IsBad")) == 0))
1163 case STATUS_STACK_OVERFLOW
:
1164 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1165 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1167 case STATUS_FLOAT_DENORMAL_OPERAND
:
1168 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1169 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1171 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1172 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1173 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1175 case STATUS_FLOAT_INEXACT_RESULT
:
1176 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1177 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1179 case STATUS_FLOAT_INVALID_OPERATION
:
1180 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1181 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1183 case STATUS_FLOAT_OVERFLOW
:
1184 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1185 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1187 case STATUS_FLOAT_STACK_CHECK
:
1188 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1189 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1191 case STATUS_FLOAT_UNDERFLOW
:
1192 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1193 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1195 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1196 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1197 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1199 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1200 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1201 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1203 case STATUS_INTEGER_OVERFLOW
:
1204 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1205 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1207 case EXCEPTION_BREAKPOINT
:
1208 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1209 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1212 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1213 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1215 case DBG_CONTROL_BREAK
:
1216 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1217 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1219 case EXCEPTION_SINGLE_STEP
:
1220 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1221 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1223 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1224 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1225 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1227 case EXCEPTION_PRIV_INSTRUCTION
:
1228 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1229 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1231 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1232 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1233 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1236 /* Treat unhandled first chance exceptions specially. */
1237 if (current_event
.u
.Exception
.dwFirstChance
)
1239 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1240 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1241 host_address_to_string (
1242 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1243 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1247 last_sig
= ourstatus
->value
.sig
;
1251 /* Resume all artificially suspended threads if we are continuing
1254 windows_continue (DWORD continue_status
, int id
)
1260 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1261 (unsigned) current_event
.dwProcessId
,
1262 (unsigned) current_event
.dwThreadId
,
1263 continue_status
== DBG_CONTINUE
?
1264 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1266 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1267 if ((id
== -1 || id
== (int) th
->id
)
1270 if (debug_registers_changed
)
1272 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1273 th
->context
.Dr0
= dr
[0];
1274 th
->context
.Dr1
= dr
[1];
1275 th
->context
.Dr2
= dr
[2];
1276 th
->context
.Dr3
= dr
[3];
1277 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1278 th
->context
.Dr7
= dr
[7];
1280 if (th
->context
.ContextFlags
)
1282 CHECK (SetThreadContext (th
->h
, &th
->context
));
1283 th
->context
.ContextFlags
= 0;
1285 if (th
->suspended
> 0)
1286 (void) ResumeThread (th
->h
);
1290 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1291 current_event
.dwThreadId
,
1294 debug_registers_changed
= 0;
1298 /* Called in pathological case where Windows fails to send a
1299 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1301 fake_create_process (void)
1303 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1304 current_event
.dwProcessId
);
1305 if (current_process_handle
!= NULL
)
1306 open_process_used
= 1;
1309 error (_("OpenProcess call failed, GetLastError = %u"),
1310 (unsigned) GetLastError ());
1311 /* We can not debug anything in that case. */
1313 main_thread_id
= current_event
.dwThreadId
;
1314 current_thread
= windows_add_thread (
1315 ptid_build (current_event
.dwProcessId
, 0,
1316 current_event
.dwThreadId
),
1317 current_event
.u
.CreateThread
.hThread
,
1318 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1319 return main_thread_id
;
1323 windows_resume (struct target_ops
*ops
,
1324 ptid_t ptid
, int step
, enum gdb_signal sig
)
1327 DWORD continue_status
= DBG_CONTINUE
;
1329 /* A specific PTID means `step only this thread id'. */
1330 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1332 /* If we're continuing all threads, it's the current inferior that
1333 should be handled specially. */
1335 ptid
= inferior_ptid
;
1337 if (sig
!= GDB_SIGNAL_0
)
1339 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1341 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1343 else if (sig
== last_sig
)
1344 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1347 /* This code does not seem to work, because
1348 the kernel does probably not consider changes in the ExceptionRecord
1349 structure when passing the exception to the inferior.
1350 Note that this seems possible in the exception handler itself. */
1353 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1354 if (xlate
[i
].us
== sig
)
1356 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1358 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1361 if (continue_status
== DBG_CONTINUE
)
1363 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1367 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1371 last_sig
= GDB_SIGNAL_0
;
1373 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1374 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1376 /* Get context for currently selected thread. */
1377 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1382 /* Single step by setting t bit. */
1383 struct regcache
*regcache
= get_current_regcache ();
1384 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1385 windows_fetch_inferior_registers (ops
, regcache
,
1386 gdbarch_ps_regnum (gdbarch
));
1387 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1390 if (th
->context
.ContextFlags
)
1392 if (debug_registers_changed
)
1394 th
->context
.Dr0
= dr
[0];
1395 th
->context
.Dr1
= dr
[1];
1396 th
->context
.Dr2
= dr
[2];
1397 th
->context
.Dr3
= dr
[3];
1398 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1399 th
->context
.Dr7
= dr
[7];
1401 CHECK (SetThreadContext (th
->h
, &th
->context
));
1402 th
->context
.ContextFlags
= 0;
1406 /* Allow continuing with the same signal that interrupted us.
1407 Otherwise complain. */
1410 windows_continue (continue_status
, -1);
1412 windows_continue (continue_status
, ptid_get_tid (ptid
));
1415 /* Ctrl-C handler used when the inferior is not run in the same console. The
1416 handler is in charge of interrupting the inferior using DebugBreakProcess.
1417 Note that this function is not available prior to Windows XP. In this case
1418 we emit a warning. */
1420 ctrl_c_handler (DWORD event_type
)
1422 const int attach_flag
= current_inferior ()->attach_flag
;
1424 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1425 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1428 /* If the inferior and the debugger share the same console, do nothing as
1429 the inferior has also received the Ctrl-C event. */
1430 if (!new_console
&& !attach_flag
)
1433 if (!DebugBreakProcess (current_process_handle
))
1434 warning (_("Could not interrupt program. "
1435 "Press Ctrl-c in the program console."));
1437 /* Return true to tell that Ctrl-C has been handled. */
1441 /* Get the next event from the child. Return 1 if the event requires
1442 handling by WFI (or whatever). */
1444 get_windows_debug_event (struct target_ops
*ops
,
1445 int pid
, struct target_waitstatus
*ourstatus
)
1448 DWORD continue_status
, event_code
;
1450 static thread_info dummy_thread_info
;
1453 last_sig
= GDB_SIGNAL_0
;
1455 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1459 continue_status
= DBG_CONTINUE
;
1461 event_code
= current_event
.dwDebugEventCode
;
1462 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1464 have_saved_context
= 0;
1468 case CREATE_THREAD_DEBUG_EVENT
:
1469 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1470 (unsigned) current_event
.dwProcessId
,
1471 (unsigned) current_event
.dwThreadId
,
1472 "CREATE_THREAD_DEBUG_EVENT"));
1473 if (saw_create
!= 1)
1475 struct inferior
*inf
;
1476 inf
= find_inferior_pid (current_event
.dwProcessId
);
1477 if (!saw_create
&& inf
->attach_flag
)
1479 /* Kludge around a Windows bug where first event is a create
1480 thread event. Caused when attached process does not have
1482 retval
= fake_create_process ();
1488 /* Record the existence of this thread. */
1489 retval
= current_event
.dwThreadId
;
1490 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1491 current_event
.dwThreadId
),
1492 current_event
.u
.CreateThread
.hThread
,
1493 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1497 case EXIT_THREAD_DEBUG_EVENT
:
1498 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1499 (unsigned) current_event
.dwProcessId
,
1500 (unsigned) current_event
.dwThreadId
,
1501 "EXIT_THREAD_DEBUG_EVENT"));
1503 if (current_event
.dwThreadId
!= main_thread_id
)
1505 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1506 current_event
.dwThreadId
),
1507 current_event
.u
.ExitThread
.dwExitCode
);
1508 th
= &dummy_thread_info
;
1512 case CREATE_PROCESS_DEBUG_EVENT
:
1513 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1514 (unsigned) current_event
.dwProcessId
,
1515 (unsigned) current_event
.dwThreadId
,
1516 "CREATE_PROCESS_DEBUG_EVENT"));
1517 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1518 if (++saw_create
!= 1)
1521 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1523 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1526 main_thread_id
= current_event
.dwThreadId
;
1527 /* Add the main thread. */
1528 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1529 current_event
.dwThreadId
),
1530 current_event
.u
.CreateProcessInfo
.hThread
,
1531 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1532 retval
= current_event
.dwThreadId
;
1535 case EXIT_PROCESS_DEBUG_EVENT
:
1536 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1537 (unsigned) current_event
.dwProcessId
,
1538 (unsigned) current_event
.dwThreadId
,
1539 "EXIT_PROCESS_DEBUG_EVENT"));
1540 if (!windows_initialization_done
)
1542 target_terminal_ours ();
1543 target_mourn_inferior ();
1544 error (_("During startup program exited with code 0x%x."),
1545 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1547 else if (saw_create
== 1)
1549 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1550 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1551 retval
= main_thread_id
;
1555 case LOAD_DLL_DEBUG_EVENT
:
1556 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1557 (unsigned) current_event
.dwProcessId
,
1558 (unsigned) current_event
.dwThreadId
,
1559 "LOAD_DLL_DEBUG_EVENT"));
1560 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1561 if (saw_create
!= 1)
1563 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1564 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1565 ourstatus
->value
.integer
= 0;
1566 retval
= main_thread_id
;
1569 case UNLOAD_DLL_DEBUG_EVENT
:
1570 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1571 (unsigned) current_event
.dwProcessId
,
1572 (unsigned) current_event
.dwThreadId
,
1573 "UNLOAD_DLL_DEBUG_EVENT"));
1574 if (saw_create
!= 1)
1576 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1577 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1578 ourstatus
->value
.integer
= 0;
1579 retval
= main_thread_id
;
1582 case EXCEPTION_DEBUG_EVENT
:
1583 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1584 (unsigned) current_event
.dwProcessId
,
1585 (unsigned) current_event
.dwThreadId
,
1586 "EXCEPTION_DEBUG_EVENT"));
1587 if (saw_create
!= 1)
1589 switch (handle_exception (ourstatus
))
1592 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1595 retval
= current_event
.dwThreadId
;
1599 continue_status
= -1;
1604 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1605 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1606 (unsigned) current_event
.dwProcessId
,
1607 (unsigned) current_event
.dwThreadId
,
1608 "OUTPUT_DEBUG_STRING_EVENT"));
1609 if (saw_create
!= 1)
1611 retval
= handle_output_debug_string (ourstatus
);
1615 if (saw_create
!= 1)
1617 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1618 (unsigned) current_event
.dwProcessId
,
1619 (unsigned) current_event
.dwThreadId
);
1620 printf_unfiltered (" unknown event code %u\n",
1621 (unsigned) current_event
.dwDebugEventCode
);
1625 if (!retval
|| saw_create
!= 1)
1627 if (continue_status
== -1)
1628 windows_resume (ops
, minus_one_ptid
, 0, 1);
1630 CHECK (windows_continue (continue_status
, -1));
1634 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1636 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1643 /* Wait for interesting events to occur in the target process. */
1645 windows_wait (struct target_ops
*ops
,
1646 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1650 target_terminal_ours ();
1652 /* We loop when we get a non-standard exception rather than return
1653 with a SPURIOUS because resume can try and step or modify things,
1654 which needs a current_thread->h. But some of these exceptions mark
1655 the birth or death of threads, which mean that the current thread
1656 isn't necessarily what you think it is. */
1662 /* If the user presses Ctrl-c while the debugger is waiting
1663 for an event, he expects the debugger to interrupt his program
1664 and to get the prompt back. There are two possible situations:
1666 - The debugger and the program do not share the console, in
1667 which case the Ctrl-c event only reached the debugger.
1668 In that case, the ctrl_c handler will take care of interrupting
1669 the inferior. Note that this case is working starting with
1670 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1673 - The debugger and the program share the same console, in which
1674 case both debugger and inferior will receive the Ctrl-c event.
1675 In that case the ctrl_c handler will ignore the event, as the
1676 Ctrl-c event generated inside the inferior will trigger the
1677 expected debug event.
1679 FIXME: brobecker/2008-05-20: If the inferior receives the
1680 signal first and the delay until GDB receives that signal
1681 is sufficiently long, GDB can sometimes receive the SIGINT
1682 after we have unblocked the CTRL+C handler. This would
1683 lead to the debugger stopping prematurely while handling
1684 the new-thread event that comes with the handling of the SIGINT
1685 inside the inferior, and then stop again immediately when
1686 the user tries to resume the execution in the inferior.
1687 This is a classic race that we should try to fix one day. */
1688 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1689 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1690 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1693 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1698 if (deprecated_ui_loop_hook
!= NULL
)
1699 detach
= deprecated_ui_loop_hook (0);
1702 windows_kill_inferior (ops
);
1708 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1710 extern int stop_after_trap
;
1712 struct inferior
*inf
;
1713 struct thread_info
*tp
;
1715 last_sig
= GDB_SIGNAL_0
;
1717 exception_count
= 0;
1718 open_process_used
= 0;
1719 debug_registers_changed
= 0;
1720 debug_registers_used
= 0;
1721 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1724 cygwin_load_start
= cygwin_load_end
= 0;
1726 current_event
.dwProcessId
= pid
;
1727 memset (¤t_event
, 0, sizeof (current_event
));
1729 disable_breakpoints_in_shlibs ();
1730 windows_clear_solib ();
1731 clear_proceed_status ();
1732 init_wait_for_inferior ();
1734 inf
= current_inferior ();
1735 inferior_appeared (inf
, pid
);
1736 inf
->attach_flag
= attaching
;
1738 /* Make the new process the current inferior, so terminal handling
1739 can rely on it. When attaching, we don't know about any thread
1740 id here, but that's OK --- nothing should be referencing the
1741 current thread until we report an event out of windows_wait. */
1742 inferior_ptid
= pid_to_ptid (pid
);
1744 terminal_init_inferior_with_pgrp (pid
);
1745 target_terminal_inferior ();
1747 windows_initialization_done
= 0;
1748 inf
->control
.stop_soon
= STOP_QUIETLY
;
1751 stop_after_trap
= 1;
1752 wait_for_inferior ();
1753 tp
= inferior_thread ();
1754 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1755 resume (0, tp
->suspend
.stop_signal
);
1760 windows_initialization_done
= 1;
1761 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1762 stop_after_trap
= 0;
1766 /* Try to set or remove a user privilege to the current process. Return -1
1767 if that fails, the previous setting of that privilege otherwise.
1769 This code is copied from the Cygwin source code and rearranged to allow
1770 dynamically loading of the needed symbols from advapi32 which is only
1771 available on NT/2K/XP. */
1773 set_process_privilege (const char *privilege
, BOOL enable
)
1775 HANDLE token_hdl
= NULL
;
1777 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1781 if (!OpenProcessToken (GetCurrentProcess (),
1782 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1786 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1789 new_priv
.PrivilegeCount
= 1;
1790 new_priv
.Privileges
[0].Luid
= restore_priv
;
1791 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1793 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1794 sizeof orig_priv
, &orig_priv
, &size
))
1797 /* Disabled, otherwise every `attach' in an unprivileged user session
1798 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1799 windows_attach(). */
1800 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1801 be enabled. GetLastError () returns an correct error code, though. */
1802 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1806 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1810 CloseHandle (token_hdl
);
1815 /* Attach to process PID, then initialize for debugging it. */
1817 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1822 pid
= parse_pid_to_attach (args
);
1824 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1826 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1827 printf_unfiltered ("This can cause attach to "
1828 "fail on Windows NT/2K/XP\n");
1831 windows_init_thread_list ();
1832 ok
= DebugActiveProcess (pid
);
1838 /* Try fall back to Cygwin pid. */
1839 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1842 ok
= DebugActiveProcess (pid
);
1847 error (_("Can't attach to process."));
1849 DebugSetProcessKillOnExit (FALSE
);
1853 char *exec_file
= (char *) get_exec_file (0);
1856 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1857 target_pid_to_str (pid_to_ptid (pid
)));
1859 printf_unfiltered ("Attaching to %s\n",
1860 target_pid_to_str (pid_to_ptid (pid
)));
1862 gdb_flush (gdb_stdout
);
1865 do_initial_windows_stuff (ops
, pid
, 1);
1866 target_terminal_ours ();
1870 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1875 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1877 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1879 error (_("Can't detach process %u (error %u)"),
1880 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1883 DebugSetProcessKillOnExit (FALSE
);
1885 if (detached
&& from_tty
)
1887 char *exec_file
= get_exec_file (0);
1890 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1891 (unsigned) current_event
.dwProcessId
);
1892 gdb_flush (gdb_stdout
);
1895 i386_cleanup_dregs ();
1896 inferior_ptid
= null_ptid
;
1897 detach_inferior (current_event
.dwProcessId
);
1899 unpush_target (ops
);
1903 windows_pid_to_exec_file (int pid
)
1905 static char path
[__PMAX
];
1907 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1909 char procexe
[sizeof ("/proc/4294967295/exe")];
1911 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1912 nchars
= readlink (procexe
, path
, sizeof(path
));
1913 if (nchars
> 0 && nchars
< sizeof (path
))
1915 path
[nchars
] = '\0'; /* Got it */
1920 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1921 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1922 if (!get_module_name (0, path
))
1928 /* Print status information about what we're accessing. */
1931 windows_files_info (struct target_ops
*ignore
)
1933 struct inferior
*inf
= current_inferior ();
1935 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1936 inf
->attach_flag
? "attached" : "child",
1937 target_pid_to_str (inferior_ptid
));
1941 windows_open (char *arg
, int from_tty
)
1943 error (_("Use the \"run\" command to start a Unix child process."));
1946 /* Modify CreateProcess parameters for use of a new separate console.
1948 *FLAGS: DWORD parameter for general process creation flags.
1949 *SI: STARTUPINFO structure, for which the console window size and
1950 console buffer size is filled in if GDB is running in a console.
1951 to create the new console.
1952 The size of the used font is not available on all versions of
1953 Windows OS. Furthermore, the current font might not be the default
1954 font, but this is still better than before.
1955 If the windows and buffer sizes are computed,
1956 SI->DWFLAGS is changed so that this information is used
1957 by CreateProcess function. */
1960 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1962 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1963 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1965 if (hconsole
!= INVALID_HANDLE_VALUE
)
1967 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1969 CONSOLE_FONT_INFO cfi
;
1971 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1972 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1973 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1974 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1975 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1977 si
->dwXSize
*= font_size
.X
;
1981 si
->dwYSize
*= font_size
.Y
;
1984 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1985 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1986 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1988 *flags
|= CREATE_NEW_CONSOLE
;
1992 /* Function called by qsort to sort environment strings. */
1995 envvar_cmp (const void *a
, const void *b
)
1997 const char **p
= (const char **) a
;
1998 const char **q
= (const char **) b
;
1999 return strcasecmp (*p
, *q
);
2005 clear_win32_environment (char **env
)
2009 wchar_t *copy
= NULL
, *equalpos
;
2011 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2013 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2014 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2015 mbstowcs (copy
, env
[i
], len
);
2016 equalpos
= wcschr (copy
, L
'=');
2019 SetEnvironmentVariableW (copy
, NULL
);
2025 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2026 EXEC_FILE is the file to run.
2027 ALLARGS is a string containing the arguments to the program.
2028 ENV is the environment vector to pass. Errors reported with error(). */
2031 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2032 char *allargs
, char **in_env
, int from_tty
)
2036 cygwin_buf_t real_path
[__PMAX
];
2037 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2039 cygwin_buf_t
*toexec
;
2040 cygwin_buf_t
*cygallargs
;
2042 char **old_env
= NULL
;
2046 int ostdin
, ostdout
, ostderr
;
2048 char real_path
[__PMAX
];
2049 char shell
[__PMAX
]; /* Path to shell */
2061 PROCESS_INFORMATION pi
;
2064 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2067 error (_("No executable specified, use `target exec'."));
2069 memset (&si
, 0, sizeof (si
));
2070 si
.cb
= sizeof (si
);
2073 flags
|= CREATE_NEW_PROCESS_GROUP
;
2076 windows_set_console_info (&si
, &flags
);
2081 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2082 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2083 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2084 error (_("Error starting executable: %d"), errno
);
2087 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2088 if (len
== (size_t) -1)
2089 error (_("Error starting executable: %d"), errno
);
2090 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2091 mbstowcs (cygallargs
, allargs
, len
);
2093 cygallargs
= allargs
;
2098 sh
= getenv ("SHELL");
2101 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2102 error (_("Error starting executable via shell: %d"), errno
);
2104 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2105 + mbstowcs (NULL
, allargs
, 0) + 2;
2106 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2107 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2109 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2110 + strlen (allargs
) + 2);
2111 cygallargs
= (char *) alloca (len
);
2112 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2115 flags
|= DEBUG_PROCESS
;
2119 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2120 * sizeof (wchar_t));
2121 wcscpy (args
, toexec
);
2122 wcscat (args
, L
" ");
2123 wcscat (args
, cygallargs
);
2125 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2126 strcpy (args
, toexec
);
2128 strcat (args
, cygallargs
);
2131 #ifdef CW_CVT_ENV_TO_WINENV
2132 /* First try to create a direct Win32 copy of the POSIX environment. */
2133 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2134 if (w32_env
!= (PWCHAR
) -1)
2135 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2137 /* If that fails, fall back to old method tweaking GDB's environment. */
2140 /* Reset all Win32 environment variables to avoid leftover on next run. */
2141 clear_win32_environment (environ
);
2142 /* Prepare the environment vars for CreateProcess. */
2145 cygwin_internal (CW_SYNC_WINENV
);
2149 if (!inferior_io_terminal
)
2150 tty
= ostdin
= ostdout
= ostderr
= -1;
2153 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2156 print_sys_errmsg (inferior_io_terminal
, errno
);
2157 ostdin
= ostdout
= ostderr
= -1;
2170 windows_init_thread_list ();
2171 ret
= CreateProcess (0,
2172 args
, /* command line */
2173 NULL
, /* Security */
2175 TRUE
, /* inherit handles */
2176 flags
, /* start flags */
2177 w32_env
, /* environment */
2178 NULL
, /* current directory */
2182 /* Just free the Win32 environment, if it could be created. */
2186 /* Reset all environment variables to avoid leftover on next run. */
2187 clear_win32_environment (in_env
);
2188 /* Restore normal GDB environment variables. */
2190 cygwin_internal (CW_SYNC_WINENV
);
2205 /* Build the command line, a space-separated list of tokens where
2206 the first token is the name of the module to be executed.
2207 To avoid ambiguities introduced by spaces in the module name,
2209 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2210 args
= alloca (args_len
);
2211 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2213 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2215 if (!inferior_io_terminal
)
2216 tty
= INVALID_HANDLE_VALUE
;
2219 SECURITY_ATTRIBUTES sa
;
2220 sa
.nLength
= sizeof(sa
);
2221 sa
.lpSecurityDescriptor
= 0;
2222 sa
.bInheritHandle
= TRUE
;
2223 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2224 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2225 if (tty
== INVALID_HANDLE_VALUE
)
2226 warning (_("Warning: Failed to open TTY %s, error %#x."),
2227 inferior_io_terminal
, (unsigned) GetLastError ());
2231 si
.hStdOutput
= tty
;
2233 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2237 /* CreateProcess takes the environment list as a null terminated set of
2238 strings (i.e. two nulls terminate the list). */
2240 /* Get total size for env strings. */
2241 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2242 envlen
+= strlen (in_env
[i
]) + 1;
2244 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2245 env
= (char **) alloca (envsize
);
2246 memcpy (env
, in_env
, envsize
);
2247 /* Windows programs expect the environment block to be sorted. */
2248 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2250 w32env
= alloca (envlen
+ 1);
2252 /* Copy env strings into new buffer. */
2253 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2255 strcpy (temp
, env
[i
]);
2256 temp
+= strlen (temp
) + 1;
2259 /* Final nil string to terminate new env. */
2262 windows_init_thread_list ();
2263 ret
= CreateProcessA (0,
2264 args
, /* command line */
2265 NULL
, /* Security */
2267 TRUE
, /* inherit handles */
2268 flags
, /* start flags */
2269 w32env
, /* environment */
2270 NULL
, /* current directory */
2273 if (tty
!= INVALID_HANDLE_VALUE
)
2278 error (_("Error creating process %s, (error %u)."),
2279 exec_file
, (unsigned) GetLastError ());
2281 CloseHandle (pi
.hThread
);
2282 CloseHandle (pi
.hProcess
);
2284 if (useshell
&& shell
[0] != '\0')
2289 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2291 /* windows_continue (DBG_CONTINUE, -1); */
2295 windows_mourn_inferior (struct target_ops
*ops
)
2297 (void) windows_continue (DBG_CONTINUE
, -1);
2298 i386_cleanup_dregs();
2299 if (open_process_used
)
2301 CHECK (CloseHandle (current_process_handle
));
2302 open_process_used
= 0;
2304 unpush_target (ops
);
2305 generic_mourn_inferior ();
2308 /* Send a SIGINT to the process group. This acts just like the user typed a
2309 ^C on the controlling terminal. */
2312 windows_stop (ptid_t ptid
)
2314 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2315 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2316 registers_changed (); /* refresh register state */
2320 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2321 int write
, struct mem_attrib
*mem
,
2322 struct target_ops
*target
)
2327 DEBUG_MEM (("gdb: write target memory, %d bytes at %s\n",
2328 len
, core_addr_to_string (memaddr
)));
2329 if (!WriteProcessMemory (current_process_handle
,
2330 (LPVOID
) (uintptr_t) memaddr
, our
,
2333 FlushInstructionCache (current_process_handle
,
2334 (LPCVOID
) (uintptr_t) memaddr
, len
);
2338 DEBUG_MEM (("gdb: read target memory, %d bytes at %s\n",
2339 len
, core_addr_to_string (memaddr
)));
2340 if (!ReadProcessMemory (current_process_handle
,
2341 (LPCVOID
) (uintptr_t) memaddr
, our
,
2349 windows_kill_inferior (struct target_ops
*ops
)
2351 CHECK (TerminateProcess (current_process_handle
, 0));
2355 if (!windows_continue (DBG_CONTINUE
, -1))
2357 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2359 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2363 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2367 windows_prepare_to_store (struct regcache
*regcache
)
2369 /* Do nothing, since we can store individual regs. */
2373 windows_can_run (void)
2379 windows_close (void)
2381 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2382 PIDGET (inferior_ptid
)));
2385 /* Convert pid to printable format. */
2387 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2389 static char buf
[80];
2391 if (ptid_get_tid (ptid
) != 0)
2393 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2394 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2398 return normal_pid_to_str (ptid
);
2402 windows_xfer_shared_libraries (struct target_ops
*ops
,
2403 enum target_object object
, const char *annex
,
2404 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2405 ULONGEST offset
, LONGEST len
)
2407 struct obstack obstack
;
2415 obstack_init (&obstack
);
2416 obstack_grow_str (&obstack
, "<library-list>\n");
2417 for (so
= solib_start
.next
; so
; so
= so
->next
)
2418 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2419 (uintptr_t) so
->lm_info
->load_addr
,
2420 target_gdbarch (), &obstack
);
2421 obstack_grow_str0 (&obstack
, "</library-list>\n");
2423 buf
= obstack_finish (&obstack
);
2424 len_avail
= strlen (buf
);
2425 if (offset
>= len_avail
)
2429 if (len
> len_avail
- offset
)
2430 len
= len_avail
- offset
;
2431 memcpy (readbuf
, buf
+ offset
, len
);
2434 obstack_free (&obstack
, NULL
);
2439 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2440 const char *annex
, gdb_byte
*readbuf
,
2441 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2445 case TARGET_OBJECT_MEMORY
:
2447 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2448 len
, 0/*read*/, NULL
, ops
);
2450 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2451 len
, 1/*write*/, NULL
, ops
);
2454 case TARGET_OBJECT_LIBRARIES
:
2455 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2456 writebuf
, offset
, len
);
2459 if (ops
->beneath
!= NULL
)
2460 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2461 readbuf
, writebuf
, offset
, len
);
2466 /* Provide thread local base, i.e. Thread Information Block address.
2467 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2470 windows_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2474 th
= thread_rec (ptid_get_tid (ptid
), 0);
2479 *addr
= th
->thread_local_base
;
2485 windows_get_ada_task_ptid (long lwp
, long thread
)
2487 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2491 init_windows_ops (void)
2493 windows_ops
.to_shortname
= "child";
2494 windows_ops
.to_longname
= "Win32 child process";
2495 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2496 windows_ops
.to_open
= windows_open
;
2497 windows_ops
.to_close
= windows_close
;
2498 windows_ops
.to_attach
= windows_attach
;
2499 windows_ops
.to_attach_no_wait
= 1;
2500 windows_ops
.to_detach
= windows_detach
;
2501 windows_ops
.to_resume
= windows_resume
;
2502 windows_ops
.to_wait
= windows_wait
;
2503 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2504 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2505 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2506 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2507 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2508 windows_ops
.to_files_info
= windows_files_info
;
2509 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2510 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2511 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2512 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2513 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2514 windows_ops
.to_terminal_ours
= terminal_ours
;
2515 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2516 windows_ops
.to_terminal_info
= child_terminal_info
;
2517 windows_ops
.to_kill
= windows_kill_inferior
;
2518 windows_ops
.to_create_inferior
= windows_create_inferior
;
2519 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2520 windows_ops
.to_can_run
= windows_can_run
;
2521 windows_ops
.to_thread_alive
= windows_thread_alive
;
2522 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2523 windows_ops
.to_stop
= windows_stop
;
2524 windows_ops
.to_stratum
= process_stratum
;
2525 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2526 windows_ops
.to_has_memory
= default_child_has_memory
;
2527 windows_ops
.to_has_stack
= default_child_has_stack
;
2528 windows_ops
.to_has_registers
= default_child_has_registers
;
2529 windows_ops
.to_has_execution
= default_child_has_execution
;
2530 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2531 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2532 windows_ops
.to_get_tib_address
= windows_get_tib_address
;
2534 i386_use_watchpoints (&windows_ops
);
2536 i386_dr_low
.set_control
= cygwin_set_dr7
;
2537 i386_dr_low
.set_addr
= cygwin_set_dr
;
2538 i386_dr_low
.get_addr
= cygwin_get_dr
;
2539 i386_dr_low
.get_status
= cygwin_get_dr6
;
2540 i386_dr_low
.get_control
= cygwin_get_dr7
;
2542 /* i386_dr_low.debug_register_length field is set by
2543 calling i386_set_debug_register_length function
2544 in processor windows specific native file. */
2546 windows_ops
.to_magic
= OPS_MAGIC
;
2550 set_windows_aliases (char *argv0
)
2552 add_info_alias ("dll", "sharedlibrary", 1);
2555 /* -Wmissing-prototypes */
2556 extern initialize_file_ftype _initialize_windows_nat
;
2559 _initialize_windows_nat (void)
2561 struct cmd_list_element
*c
;
2563 init_windows_ops ();
2566 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2569 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2570 _("Load dll library symbols from FILE."));
2571 set_cmd_completer (c
, filename_completer
);
2573 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2575 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2577 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2580 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2581 Set use of shell to start subprocess."), _("\
2582 Show use of shell to start subprocess."), NULL
,
2584 NULL
, /* FIXME: i18n: */
2585 &setlist
, &showlist
);
2587 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2588 &cygwin_exceptions
, _("\
2589 Break when an exception is detected in the Cygwin DLL itself."), _("\
2590 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2592 NULL
, /* FIXME: i18n: */
2593 &setlist
, &showlist
);
2596 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2597 Set creation of new console when creating child process."), _("\
2598 Show creation of new console when creating child process."), NULL
,
2600 NULL
, /* FIXME: i18n: */
2601 &setlist
, &showlist
);
2603 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2604 Set creation of new group when creating child process."), _("\
2605 Show creation of new group when creating child process."), NULL
,
2607 NULL
, /* FIXME: i18n: */
2608 &setlist
, &showlist
);
2610 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2611 Set whether to display execution in child process."), _("\
2612 Show whether to display execution in child process."), NULL
,
2614 NULL
, /* FIXME: i18n: */
2615 &setlist
, &showlist
);
2617 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2618 Set whether to display kernel events in child process."), _("\
2619 Show whether to display kernel events in child process."), NULL
,
2621 NULL
, /* FIXME: i18n: */
2622 &setlist
, &showlist
);
2624 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2625 Set whether to display memory accesses in child process."), _("\
2626 Show whether to display memory accesses in child process."), NULL
,
2628 NULL
, /* FIXME: i18n: */
2629 &setlist
, &showlist
);
2631 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2632 &debug_exceptions
, _("\
2633 Set whether to display kernel exceptions in child process."), _("\
2634 Show whether to display kernel exceptions in child process."), NULL
,
2636 NULL
, /* FIXME: i18n: */
2637 &setlist
, &showlist
);
2639 init_w32_command_list ();
2641 add_cmd ("selector", class_info
, display_selectors
,
2642 _("Display selectors infos."),
2644 add_target (&windows_ops
);
2645 deprecated_init_ui_hook
= set_windows_aliases
;
2648 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2650 /* Pass the address ADDR to the inferior in the I'th debug register.
2651 Here we just store the address in dr array, the registers will be
2652 actually set up when windows_continue is called. */
2654 cygwin_set_dr (int i
, CORE_ADDR addr
)
2657 internal_error (__FILE__
, __LINE__
,
2658 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2660 debug_registers_changed
= 1;
2661 debug_registers_used
= 1;
2664 /* Pass the value VAL to the inferior in the DR7 debug control
2665 register. Here we just store the address in D_REGS, the watchpoint
2666 will be actually set up in windows_wait. */
2668 cygwin_set_dr7 (unsigned long val
)
2670 dr
[7] = (CORE_ADDR
) val
;
2671 debug_registers_changed
= 1;
2672 debug_registers_used
= 1;
2675 /* Get the value of debug register I from the inferior. */
2678 cygwin_get_dr (int i
)
2683 /* Get the value of the DR6 debug status register from the inferior.
2684 Here we just return the value stored in dr[6]
2685 by the last call to thread_rec for current_event.dwThreadId id. */
2686 static unsigned long
2687 cygwin_get_dr6 (void)
2689 return (unsigned long) dr
[6];
2692 /* Get the value of the DR7 debug status register from the inferior.
2693 Here we just return the value stored in dr[7] by the last call to
2694 thread_rec for current_event.dwThreadId id. */
2696 static unsigned long
2697 cygwin_get_dr7 (void)
2699 return (unsigned long) dr
[7];
2702 /* Determine if the thread referenced by "ptid" is alive
2703 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2704 it means that the thread has died. Otherwise it is assumed to be alive. */
2706 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2710 gdb_assert (ptid_get_tid (ptid
) != 0);
2711 tid
= ptid_get_tid (ptid
);
2713 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2717 /* -Wmissing-prototypes */
2718 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2721 _initialize_check_for_gdb_ini (void)
2724 if (inhibit_gdbinit
)
2727 homedir
= getenv ("HOME");
2731 char *oldini
= (char *) alloca (strlen (homedir
) +
2732 sizeof ("/gdb.ini"));
2733 strcpy (oldini
, homedir
);
2734 p
= strchr (oldini
, '\0');
2735 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2737 strcpy (p
, "gdb.ini");
2738 if (access (oldini
, 0) == 0)
2740 int len
= strlen (oldini
);
2741 char *newini
= alloca (len
+ 1);
2743 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2744 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2745 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2750 /* Define dummy functions which always return error for the rare cases where
2751 these functions could not be found. */
2753 bad_DebugActiveProcessStop (DWORD w
)
2758 bad_DebugBreakProcess (HANDLE w
)
2763 bad_DebugSetProcessKillOnExit (BOOL w
)
2768 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2775 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2781 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2788 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2794 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2800 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2806 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2814 /* -Wmissing-prototypes */
2815 extern initialize_file_ftype _initialize_loadable
;
2817 /* Load any functions which may not be available in ancient versions
2821 _initialize_loadable (void)
2825 hm
= LoadLibrary ("kernel32.dll");
2828 DebugActiveProcessStop
= (void *)
2829 GetProcAddress (hm
, "DebugActiveProcessStop");
2830 DebugBreakProcess
= (void *)
2831 GetProcAddress (hm
, "DebugBreakProcess");
2832 DebugSetProcessKillOnExit
= (void *)
2833 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2834 GetConsoleFontSize
= (void *)
2835 GetProcAddress (hm
, "GetConsoleFontSize");
2836 GetCurrentConsoleFont
= (void *)
2837 GetProcAddress (hm
, "GetCurrentConsoleFont");
2840 /* Set variables to dummy versions of these processes if the function
2841 wasn't found in kernel32.dll. */
2842 if (!DebugBreakProcess
)
2843 DebugBreakProcess
= bad_DebugBreakProcess
;
2844 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2846 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2847 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2849 if (!GetConsoleFontSize
)
2850 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2851 if (!GetCurrentConsoleFont
)
2852 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2854 /* Load optional functions used for retrieving filename information
2855 associated with the currently debugged process or its dlls. */
2856 hm
= LoadLibrary ("psapi.dll");
2859 EnumProcessModules
= (void *)
2860 GetProcAddress (hm
, "EnumProcessModules");
2861 GetModuleInformation
= (void *)
2862 GetProcAddress (hm
, "GetModuleInformation");
2863 GetModuleFileNameEx
= (void *)
2864 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2867 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2869 /* Set variables to dummy versions of these processes if the function
2870 wasn't found in psapi.dll. */
2871 EnumProcessModules
= bad_EnumProcessModules
;
2872 GetModuleInformation
= bad_GetModuleInformation
;
2873 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2874 /* This will probably fail on Windows 9x/Me. Let the user know
2875 that we're missing some functionality. */
2877 cannot automatically find executable file or library to read symbols.\n\
2878 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2881 hm
= LoadLibrary ("advapi32.dll");
2884 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2885 LookupPrivilegeValueA
= (void *)
2886 GetProcAddress (hm
, "LookupPrivilegeValueA");
2887 AdjustTokenPrivileges
= (void *)
2888 GetProcAddress (hm
, "AdjustTokenPrivileges");
2889 /* Only need to set one of these since if OpenProcessToken fails nothing
2891 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2892 || !AdjustTokenPrivileges
)
2893 OpenProcessToken
= bad_OpenProcessToken
;