1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
28 #include "exceptions.h"
31 #include "completer.h"
35 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
49 #include "filenames.h"
53 #include "gdb_obstack.h"
54 #include "gdb_string.h"
55 #include "gdbthread.h"
57 #include <sys/param.h>
62 #include "xml-support.h"
64 #include "i386-tdep.h"
65 #include "i387-tdep.h"
67 #include "windows-tdep.h"
68 #include "windows-nat.h"
70 #include "complaints.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
84 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
85 static BOOL
WINAPI (*DebugActiveProcessStop
) (DWORD
);
86 static BOOL
WINAPI (*DebugBreakProcess
) (HANDLE
);
87 static BOOL
WINAPI (*DebugSetProcessKillOnExit
) (BOOL
);
88 static BOOL
WINAPI (*EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
,
90 static BOOL
WINAPI (*GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
,
92 static BOOL
WINAPI (*LookupPrivilegeValueA
)(LPCSTR
, LPCSTR
, PLUID
);
93 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
94 static BOOL
WINAPI (*GetCurrentConsoleFont
) (HANDLE
, BOOL
,
96 static COORD
WINAPI (*GetConsoleFontSize
) (HANDLE
, DWORD
);
98 static struct target_ops windows_ops
;
102 #undef GetModuleFileNameEx
105 # define __PMAX (MAX_PATH + 1)
106 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
, LPSTR
, DWORD
);
107 # define STARTUPINFO STARTUPINFOA
108 # define CreateProcess CreateProcessA
109 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
110 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
112 # define __PMAX PATH_MAX
113 /* The starting and ending address of the cygwin1.dll text segment. */
114 static CORE_ADDR cygwin_load_start
;
115 static CORE_ADDR cygwin_load_end
;
117 typedef wchar_t cygwin_buf_t
;
118 static DWORD
WINAPI (*GetModuleFileNameEx
) (HANDLE
, HMODULE
,
120 # define STARTUPINFO STARTUPINFOW
121 # define CreateProcess CreateProcessW
122 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
123 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
126 static int have_saved_context
; /* True if we've saved context from a
128 static CONTEXT saved_context
; /* Containes the saved context from a
131 /* If we're not using the old Cygwin header file set, define the
132 following which never should have been in the generic Win32 API
133 headers in the first place since they were our own invention... */
134 #ifndef _GNU_H_WINDOWS_H
137 FLAG_TRACE_BIT
= 0x100,
138 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
142 #ifndef CONTEXT_EXTENDED_REGISTERS
143 /* This macro is only defined on ia32. It only makes sense on this target,
144 so define it as zero if not already defined. */
145 #define CONTEXT_EXTENDED_REGISTERS 0
148 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
149 | CONTEXT_EXTENDED_REGISTERS
151 static uintptr_t dr
[8];
152 static int debug_registers_changed
;
153 static int debug_registers_used
;
155 static int windows_initialization_done
;
156 #define DR6_CLEAR_VALUE 0xffff0ff0
158 /* The string sent by cygwin when it processes a signal.
159 FIXME: This should be in a cygwin include file. */
160 #ifndef _CYGWIN_SIGNAL_STRING
161 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
164 #define CHECK(x) check (x, __FILE__,__LINE__)
165 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
166 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
167 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
168 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
170 static void windows_stop (ptid_t
);
171 static int windows_thread_alive (struct target_ops
*, ptid_t
);
172 static void windows_kill_inferior (struct target_ops
*);
174 static void cygwin_set_dr (int i
, CORE_ADDR addr
);
175 static void cygwin_set_dr7 (unsigned long val
);
176 static CORE_ADDR
cygwin_get_dr (int i
);
177 static unsigned long cygwin_get_dr6 (void);
178 static unsigned long cygwin_get_dr7 (void);
180 static enum gdb_signal last_sig
= GDB_SIGNAL_0
;
181 /* Set if a signal was received from the debugged process. */
183 /* Thread information structure used to track information that is
184 not available in gdb's thread structure. */
185 typedef struct thread_info_struct
187 struct thread_info_struct
*next
;
190 CORE_ADDR thread_local_base
;
199 static thread_info thread_head
;
201 /* The process and thread handles for the above context. */
203 static DEBUG_EVENT current_event
; /* The current debug event from
205 static HANDLE current_process_handle
; /* Currently executing process */
206 static thread_info
*current_thread
; /* Info on currently selected thread */
207 static DWORD main_thread_id
; /* Thread ID of the main thread */
209 /* Counts of things. */
210 static int exception_count
= 0;
211 static int event_count
= 0;
212 static int saw_create
;
213 static int open_process_used
= 0;
216 static int new_console
= 0;
218 static int cygwin_exceptions
= 0;
220 static int new_group
= 1;
221 static int debug_exec
= 0; /* show execution */
222 static int debug_events
= 0; /* show events from kernel */
223 static int debug_memory
= 0; /* show target memory accesses */
224 static int debug_exceptions
= 0; /* show target exceptions */
225 static int useshell
= 0; /* use shell for subprocesses */
227 /* This vector maps GDB's idea of a register's number into an offset
228 in the windows exception context vector.
230 It also contains the bit mask needed to load the register in question.
232 The contents of this table can only be computed by the units
233 that provide CPU-specific support for Windows native debugging.
234 These units should set the table by calling
235 windows_set_context_register_offsets.
237 One day we could read a reg, we could inspect the context we
238 already have loaded, if it doesn't have the bit set that we need,
239 we read that set of registers in using GetThreadContext. If the
240 context already contains what we need, we just unpack it. Then to
241 write a register, first we have to ensure that the context contains
242 the other regs of the group, and then we copy the info in and set
245 static const int *mappings
;
247 /* The function to use in order to determine whether a register is
248 a segment register or not. */
249 static segment_register_p_ftype
*segment_register_p
;
251 /* This vector maps the target's idea of an exception (extracted
252 from the DEBUG_EVENT structure) to GDB's idea. */
254 struct xlate_exception
260 static const struct xlate_exception
263 {EXCEPTION_ACCESS_VIOLATION
, GDB_SIGNAL_SEGV
},
264 {STATUS_STACK_OVERFLOW
, GDB_SIGNAL_SEGV
},
265 {EXCEPTION_BREAKPOINT
, GDB_SIGNAL_TRAP
},
266 {DBG_CONTROL_C
, GDB_SIGNAL_INT
},
267 {EXCEPTION_SINGLE_STEP
, GDB_SIGNAL_TRAP
},
268 {STATUS_FLOAT_DIVIDE_BY_ZERO
, GDB_SIGNAL_FPE
},
271 /* Set the MAPPINGS static global to OFFSETS.
272 See the description of MAPPINGS for more details. */
275 windows_set_context_register_offsets (const int *offsets
)
280 /* See windows-nat.h. */
283 windows_set_segment_register_p (segment_register_p_ftype
*fun
)
285 segment_register_p
= fun
;
289 check (BOOL ok
, const char *file
, int line
)
292 printf_filtered ("error return %s:%d was %u\n", file
, line
,
293 (unsigned) GetLastError ());
296 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
297 then also retrieve the context for this thread. If GET_CONTEXT is
298 negative, then don't suspend the thread. */
300 thread_rec (DWORD id
, int get_context
)
304 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
307 if (!th
->suspended
&& get_context
)
309 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
311 if (SuspendThread (th
->h
) == (DWORD
) -1)
313 DWORD err
= GetLastError ();
314 warning (_("SuspendThread failed. (winerr %u)"),
320 else if (get_context
< 0)
322 th
->reload_context
= 1;
330 /* Add a thread to the thread list. */
332 windows_add_thread (ptid_t ptid
, HANDLE h
, void *tlb
)
337 gdb_assert (ptid_get_tid (ptid
) != 0);
339 id
= ptid_get_tid (ptid
);
341 if ((th
= thread_rec (id
, FALSE
)))
344 th
= XZALLOC (thread_info
);
347 th
->thread_local_base
= (CORE_ADDR
) (uintptr_t) tlb
;
348 th
->next
= thread_head
.next
;
349 thread_head
.next
= th
;
351 /* Set the debug registers for the new thread if they are used. */
352 if (debug_registers_used
)
354 /* Only change the value of the debug registers. */
355 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
356 CHECK (GetThreadContext (th
->h
, &th
->context
));
357 th
->context
.Dr0
= dr
[0];
358 th
->context
.Dr1
= dr
[1];
359 th
->context
.Dr2
= dr
[2];
360 th
->context
.Dr3
= dr
[3];
361 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
362 th
->context
.Dr7
= dr
[7];
363 CHECK (SetThreadContext (th
->h
, &th
->context
));
364 th
->context
.ContextFlags
= 0;
369 /* Clear out any old thread list and reintialize it to a
372 windows_init_thread_list (void)
374 thread_info
*th
= &thread_head
;
376 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
378 while (th
->next
!= NULL
)
380 thread_info
*here
= th
->next
;
381 th
->next
= here
->next
;
384 thread_head
.next
= NULL
;
387 /* Delete a thread from the list of threads. */
389 windows_delete_thread (ptid_t ptid
)
394 gdb_assert (ptid_get_tid (ptid
) != 0);
396 id
= ptid_get_tid (ptid
);
399 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid
));
400 delete_thread (ptid
);
402 for (th
= &thread_head
;
403 th
->next
!= NULL
&& th
->next
->id
!= id
;
407 if (th
->next
!= NULL
)
409 thread_info
*here
= th
->next
;
410 th
->next
= here
->next
;
416 do_windows_fetch_inferior_registers (struct regcache
*regcache
, int r
)
418 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
419 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
420 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
424 return; /* Windows sometimes uses a non-existent thread id in its
427 if (current_thread
->reload_context
)
429 #ifdef __COPY_CONTEXT_SIZE
430 if (have_saved_context
)
432 /* Lie about where the program actually is stopped since
433 cygwin has informed us that we should consider the signal
434 to have occurred at another location which is stored in
436 memcpy (¤t_thread
->context
, &saved_context
,
437 __COPY_CONTEXT_SIZE
);
438 have_saved_context
= 0;
443 thread_info
*th
= current_thread
;
444 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
445 GetThreadContext (th
->h
, &th
->context
);
446 /* Copy dr values from that thread.
447 But only if there were not modified since last stop.
449 if (!debug_registers_changed
)
451 dr
[0] = th
->context
.Dr0
;
452 dr
[1] = th
->context
.Dr1
;
453 dr
[2] = th
->context
.Dr2
;
454 dr
[3] = th
->context
.Dr3
;
455 dr
[6] = th
->context
.Dr6
;
456 dr
[7] = th
->context
.Dr7
;
459 current_thread
->reload_context
= 0;
462 if (r
== I387_FISEG_REGNUM (tdep
))
464 l
= *((long *) context_offset
) & 0xffff;
465 regcache_raw_supply (regcache
, r
, (char *) &l
);
467 else if (r
== I387_FOP_REGNUM (tdep
))
469 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
470 regcache_raw_supply (regcache
, r
, (char *) &l
);
472 else if (segment_register_p (r
))
474 /* GDB treats segment registers as 32bit registers, but they are
475 in fact only 16 bits long. Make sure we do not read extra
476 bits from our source buffer. */
477 l
= *((long *) context_offset
) & 0xffff;
478 regcache_raw_supply (regcache
, r
, (char *) &l
);
481 regcache_raw_supply (regcache
, r
, context_offset
);
484 for (r
= 0; r
< gdbarch_num_regs (gdbarch
); r
++)
485 do_windows_fetch_inferior_registers (regcache
, r
);
490 windows_fetch_inferior_registers (struct target_ops
*ops
,
491 struct regcache
*regcache
, int r
)
493 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
494 /* Check if current_thread exists. Windows sometimes uses a non-existent
495 thread id in its events. */
497 do_windows_fetch_inferior_registers (regcache
, r
);
501 do_windows_store_inferior_registers (const struct regcache
*regcache
, int r
)
504 /* Windows sometimes uses a non-existent thread id in its events. */;
506 regcache_raw_collect (regcache
, r
,
507 ((char *) ¤t_thread
->context
) + mappings
[r
]);
510 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
511 do_windows_store_inferior_registers (regcache
, r
);
515 /* Store a new register value into the current thread context. */
517 windows_store_inferior_registers (struct target_ops
*ops
,
518 struct regcache
*regcache
, int r
)
520 current_thread
= thread_rec (ptid_get_tid (inferior_ptid
), TRUE
);
521 /* Check if current_thread exists. Windows sometimes uses a non-existent
522 thread id in its events. */
524 do_windows_store_inferior_registers (regcache
, r
);
527 /* Get the name of a given module at given base address. If base_address
528 is zero return the first loaded module (which is always the name of the
531 get_module_name (LPVOID base_address
, char *dll_name_ret
)
537 HMODULE
*DllHandle
= dh_buf
; /* Set to temporary storage for
541 cygwin_buf_t pathbuf
[__PMAX
]; /* Temporary storage prior to converting to
542 posix form. __PMAX is always enough
543 as long as SO_NAME_MAX_PATH_SIZE is defined
548 /* Find size of buffer needed to handle list of modules loaded in
550 if (!EnumProcessModules (current_process_handle
, DllHandle
,
551 sizeof (HMODULE
), &cbNeeded
) || !cbNeeded
)
554 /* Allocate correct amount of space for module list. */
555 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
559 /* Get the list of modules. */
560 if (!EnumProcessModules (current_process_handle
, DllHandle
, cbNeeded
,
564 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
566 /* Get information on this module. */
567 if (!GetModuleInformation (current_process_handle
, DllHandle
[i
],
569 error (_("Can't get module info"));
571 if (!base_address
|| mi
.lpBaseOfDll
== base_address
)
573 /* Try to find the name of the given module. */
575 /* Cygwin prefers that the path be in /x/y/z format. */
576 len
= GetModuleFileNameEx (current_process_handle
,
577 DllHandle
[i
], pathbuf
, __PMAX
);
579 error (_("Error getting dll name: %u."),
580 (unsigned) GetLastError ());
581 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX
, pathbuf
, dll_name_ret
,
583 error (_("Error converting dll name to POSIX: %d."), errno
);
585 len
= GetModuleFileNameEx (current_process_handle
,
586 DllHandle
[i
], dll_name_ret
, __PMAX
);
588 error (_("Error getting dll name: %u."),
589 (unsigned) GetLastError ());
591 return 1; /* success */
596 dll_name_ret
[0] = '\0';
597 return 0; /* failure */
600 /* Return an absolute file name of the running GDB, if possible, or
601 ARGV0 if not. The return value is in malloc'ed storage. */
603 windows_get_absolute_argv0 (const char *argv0
)
605 char full_name
[PATH_MAX
];
607 if (GetModuleFileName (NULL
, full_name
, PATH_MAX
))
608 return xstrdup (full_name
);
609 return xstrdup (argv0
);
612 /* Encapsulate the information required in a call to
613 symbol_file_add_args. */
614 struct safe_symbol_file_add_args
618 struct section_addr_info
*addrs
;
621 struct ui_file
*err
, *out
;
625 /* Maintain a linked list of "so" information. */
631 static struct so_list solib_start
, *solib_end
;
633 /* Call symbol_file_add with stderr redirected. We don't care if there
636 safe_symbol_file_add_stub (void *argv
)
638 #define p ((struct safe_symbol_file_add_args *) argv)
639 const int add_flags
= ((p
->from_tty
? SYMFILE_VERBOSE
: 0)
640 | (p
->mainline
? SYMFILE_MAINLINE
: 0));
641 p
->ret
= symbol_file_add (p
->name
, add_flags
, p
->addrs
, p
->flags
);
646 /* Restore gdb's stderr after calling symbol_file_add. */
648 safe_symbol_file_add_cleanup (void *p
)
650 #define sp ((struct safe_symbol_file_add_args *)p)
651 gdb_flush (gdb_stderr
);
652 gdb_flush (gdb_stdout
);
653 ui_file_delete (gdb_stderr
);
654 ui_file_delete (gdb_stdout
);
655 gdb_stderr
= sp
->err
;
656 gdb_stdout
= sp
->out
;
660 /* symbol_file_add wrapper that prevents errors from being displayed. */
661 static struct objfile
*
662 safe_symbol_file_add (char *name
, int from_tty
,
663 struct section_addr_info
*addrs
,
664 int mainline
, int flags
)
666 struct safe_symbol_file_add_args p
;
667 struct cleanup
*cleanup
;
669 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
673 gdb_flush (gdb_stderr
);
674 gdb_flush (gdb_stdout
);
675 gdb_stderr
= ui_file_new ();
676 gdb_stdout
= ui_file_new ();
678 p
.from_tty
= from_tty
;
680 p
.mainline
= mainline
;
682 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
684 do_cleanups (cleanup
);
688 static struct so_list
*
689 windows_make_so (const char *name
, LPVOID load_addr
)
696 WIN32_FIND_DATA w32_fd
;
697 HANDLE h
= FindFirstFile(name
, &w32_fd
);
699 if (h
== INVALID_HANDLE_VALUE
)
705 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
707 p
= strrchr (buf
, '\\');
710 SetCurrentDirectory (buf
);
711 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
712 SetCurrentDirectory (cwd
);
715 if (strcasecmp (buf
, "ntdll.dll") == 0)
717 GetSystemDirectory (buf
, sizeof (buf
));
718 strcat (buf
, "\\ntdll.dll");
721 cygwin_buf_t buf
[__PMAX
];
724 if (access (name
, F_OK
) != 0)
726 if (strcasecmp (name
, "ntdll.dll") == 0)
729 GetSystemDirectoryW (buf
, sizeof (buf
) / sizeof (wchar_t));
730 wcscat (buf
, L
"\\ntdll.dll");
734 GetSystemDirectoryA (buf
, sizeof (buf
) / sizeof (wchar_t));
735 strcat (buf
, "\\ntdll.dll");
740 so
= XZALLOC (struct so_list
);
741 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
742 so
->lm_info
->load_addr
= load_addr
;
743 strcpy (so
->so_original_name
, name
);
745 strcpy (so
->so_name
, buf
);
748 cygwin_conv_path (CCP_WIN_W_TO_POSIX
, buf
, so
->so_name
,
749 SO_NAME_MAX_PATH_SIZE
);
752 char *rname
= realpath (name
, NULL
);
753 if (rname
&& strlen (rname
) < SO_NAME_MAX_PATH_SIZE
)
755 strcpy (so
->so_name
, rname
);
759 error (_("dll path too long"));
761 /* Record cygwin1.dll .text start/end. */
762 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
763 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
766 asection
*text
= NULL
;
769 abfd
= gdb_bfd_open (so
->so_name
, "pei-i386", -1);
774 if (bfd_check_format (abfd
, bfd_object
))
775 text
= bfd_get_section_by_name (abfd
, ".text");
779 gdb_bfd_unref (abfd
);
783 /* The symbols in a dll are offset by 0x1000, which is the
784 offset from 0 of the first byte in an image - because of the
785 file header and the section alignment. */
786 cygwin_load_start
= (CORE_ADDR
) (uintptr_t) ((char *)
788 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
790 gdb_bfd_unref (abfd
);
798 get_image_name (HANDLE h
, void *address
, int unicode
)
801 static char buf
[__PMAX
];
803 static char buf
[(2 * __PMAX
) + 1];
805 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
811 /* Attempt to read the name of the dll that was detected.
812 This is documented to work only when actively debugging
813 a program. It will not work for attached processes. */
817 /* See if we could read the address of a string, and that the
818 address isn't null. */
819 if (!ReadProcessMemory (h
, address
, &address_ptr
,
820 sizeof (address_ptr
), &done
)
821 || done
!= sizeof (address_ptr
) || !address_ptr
)
824 /* Find the length of the string. */
825 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
826 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
830 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
833 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
834 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
837 wcstombs (buf
, unicode_address
, __PMAX
);
839 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, sizeof buf
,
847 /* Wait for child to do something. Return pid of child, or -1 in case
848 of error; store status through argument pointer OURSTATUS. */
850 handle_load_dll (void *dummy
)
852 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
853 char dll_buf
[__PMAX
];
854 char *dll_name
= NULL
;
856 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
858 if (!get_module_name (event
->lpBaseOfDll
, dll_buf
))
859 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
863 if (*dll_name
== '\0')
864 dll_name
= get_image_name (current_process_handle
,
865 event
->lpImageName
, event
->fUnicode
);
869 solib_end
->next
= windows_make_so (dll_name
, event
->lpBaseOfDll
);
870 solib_end
= solib_end
->next
;
872 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end
->so_name
,
873 host_address_to_string (solib_end
->lm_info
->load_addr
)));
879 windows_free_so (struct so_list
*so
)
887 handle_unload_dll (void *dummy
)
889 LPVOID lpBaseOfDll
= current_event
.u
.UnloadDll
.lpBaseOfDll
;
892 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
893 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
895 struct so_list
*sodel
= so
->next
;
896 so
->next
= sodel
->next
;
899 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel
->so_name
));
901 windows_free_so (sodel
);
902 solib_add (NULL
, 0, NULL
, auto_solib_add
);
906 /* We did not find any DLL that was previously loaded at this address,
907 so register a complaint. We do not report an error, because we have
908 observed that this may be happening under some circumstances. For
909 instance, running 32bit applications on x64 Windows causes us to receive
910 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
911 events are apparently caused by the WOW layer, the interface between
912 32bit and 64bit worlds). */
913 complaint (&symfile_complaints
, _("dll starting at %s not found."),
914 host_address_to_string (lpBaseOfDll
));
919 /* Clear list of loaded DLLs. */
921 windows_clear_solib (void)
923 solib_start
.next
= NULL
;
924 solib_end
= &solib_start
;
927 /* Load DLL symbol info. */
929 dll_symbol_command (char *args
, int from_tty
)
935 error (_("dll-symbols requires a file name"));
938 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
940 char *newargs
= (char *) alloca (n
+ 4 + 1);
941 strcpy (newargs
, args
);
942 strcat (newargs
, ".dll");
946 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
949 /* Handle DEBUG_STRING output from child process.
950 Cygwin prepends its messages with a "cygwin:". Interpret this as
951 a Cygwin signal. Otherwise just print the string as a warning. */
953 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
958 if (!target_read_string
959 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
963 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
,
964 sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
967 if (strncmp (s
, "cYg", 3) != 0)
971 #ifdef __COPY_CONTEXT_SIZE
974 /* Got a cygwin signal marker. A cygwin signal is followed by
975 the signal number itself and then optionally followed by the
976 thread id and address to saved context within the DLL. If
977 these are supplied, then the given thread is assumed to have
978 issued the signal and the context from the thread is assumed
979 to be stored at the given address in the inferior. Tell gdb
980 to treat this like a real signal. */
982 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
983 int gotasig
= gdb_signal_from_host (sig
);
985 ourstatus
->value
.sig
= gotasig
;
991 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
992 retval
= strtoul (p
, &p
, 0);
994 retval
= main_thread_id
;
995 else if ((x
= (LPCVOID
) (uintptr_t) strtoull (p
, NULL
, 0))
996 && ReadProcessMemory (current_process_handle
, x
,
998 __COPY_CONTEXT_SIZE
, &n
)
999 && n
== __COPY_CONTEXT_SIZE
)
1000 have_saved_context
= 1;
1001 current_event
.dwThreadId
= retval
;
1012 display_selector (HANDLE thread
, DWORD sel
)
1015 if (GetThreadSelectorEntry (thread
, sel
, &info
))
1018 printf_filtered ("0x%03x: ", (unsigned) sel
);
1019 if (!info
.HighWord
.Bits
.Pres
)
1021 puts_filtered ("Segment not present\n");
1024 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
1025 (info
.HighWord
.Bits
.BaseMid
<< 16)
1027 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
1028 if (info
.HighWord
.Bits
.Granularity
)
1029 limit
= (limit
<< 12) | 0xfff;
1030 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
1031 if (info
.HighWord
.Bits
.Default_Big
)
1032 puts_filtered(" 32-bit ");
1034 puts_filtered(" 16-bit ");
1035 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
1038 puts_filtered ("Data (Read-Only, Exp-up");
1041 puts_filtered ("Data (Read/Write, Exp-up");
1044 puts_filtered ("Unused segment (");
1047 puts_filtered ("Data (Read/Write, Exp-down");
1050 puts_filtered ("Code (Exec-Only, N.Conf");
1053 puts_filtered ("Code (Exec/Read, N.Conf");
1056 puts_filtered ("Code (Exec-Only, Conf");
1059 puts_filtered ("Code (Exec/Read, Conf");
1062 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1064 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1065 puts_filtered(", N.Acc");
1066 puts_filtered (")\n");
1067 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1068 puts_filtered("System selector ");
1069 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1070 if (info
.HighWord
.Bits
.Granularity
)
1071 puts_filtered ("Page granular.\n");
1073 puts_filtered ("Byte granular.\n");
1078 DWORD err
= GetLastError ();
1079 if (err
== ERROR_NOT_SUPPORTED
)
1080 printf_filtered ("Function not supported\n");
1082 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel
);
1088 display_selectors (char * args
, int from_tty
)
1090 if (!current_thread
)
1092 puts_filtered ("Impossible to display selectors now.\n");
1098 puts_filtered ("Selector $cs\n");
1099 display_selector (current_thread
->h
,
1100 current_thread
->context
.SegCs
);
1101 puts_filtered ("Selector $ds\n");
1102 display_selector (current_thread
->h
,
1103 current_thread
->context
.SegDs
);
1104 puts_filtered ("Selector $es\n");
1105 display_selector (current_thread
->h
,
1106 current_thread
->context
.SegEs
);
1107 puts_filtered ("Selector $ss\n");
1108 display_selector (current_thread
->h
,
1109 current_thread
->context
.SegSs
);
1110 puts_filtered ("Selector $fs\n");
1111 display_selector (current_thread
->h
,
1112 current_thread
->context
.SegFs
);
1113 puts_filtered ("Selector $gs\n");
1114 display_selector (current_thread
->h
,
1115 current_thread
->context
.SegGs
);
1120 sel
= parse_and_eval_long (args
);
1121 printf_filtered ("Selector \"%s\"\n",args
);
1122 display_selector (current_thread
->h
, sel
);
1126 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1127 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1128 host_address_to_string (\
1129 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1132 handle_exception (struct target_waitstatus
*ourstatus
)
1135 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1137 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1139 /* Record the context of the current thread. */
1140 th
= thread_rec (current_event
.dwThreadId
, -1);
1144 case EXCEPTION_ACCESS_VIOLATION
:
1145 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1146 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1149 /* See if the access violation happened within the cygwin DLL
1150 itself. Cygwin uses a kind of exception handling to deal
1151 with passed-in invalid addresses. gdb should not treat
1152 these as real SEGVs since they will be silently handled by
1153 cygwin. A real SEGV will (theoretically) be caught by
1154 cygwin later in the process and will be sent as a
1155 cygwin-specific-signal. So, ignore SEGVs if they show up
1156 within the text segment of the DLL itself. */
1158 CORE_ADDR addr
= (CORE_ADDR
) (uintptr_t)
1159 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1161 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
1162 && addr
< cygwin_load_end
))
1163 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1164 && strncmp (fn
, "KERNEL32!IsBad",
1165 strlen ("KERNEL32!IsBad")) == 0))
1170 case STATUS_STACK_OVERFLOW
:
1171 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1172 ourstatus
->value
.sig
= GDB_SIGNAL_SEGV
;
1174 case STATUS_FLOAT_DENORMAL_OPERAND
:
1175 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1176 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1178 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1179 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1180 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1182 case STATUS_FLOAT_INEXACT_RESULT
:
1183 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1184 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1186 case STATUS_FLOAT_INVALID_OPERATION
:
1187 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1188 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1190 case STATUS_FLOAT_OVERFLOW
:
1191 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1192 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1194 case STATUS_FLOAT_STACK_CHECK
:
1195 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1196 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1198 case STATUS_FLOAT_UNDERFLOW
:
1199 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1200 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1202 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1203 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1204 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1206 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1207 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1208 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1210 case STATUS_INTEGER_OVERFLOW
:
1211 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1212 ourstatus
->value
.sig
= GDB_SIGNAL_FPE
;
1214 case EXCEPTION_BREAKPOINT
:
1215 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1216 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1219 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1220 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1222 case DBG_CONTROL_BREAK
:
1223 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1224 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
1226 case EXCEPTION_SINGLE_STEP
:
1227 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1228 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
1230 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1231 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1232 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1234 case EXCEPTION_PRIV_INSTRUCTION
:
1235 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1236 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1238 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1239 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1240 ourstatus
->value
.sig
= GDB_SIGNAL_ILL
;
1243 /* Treat unhandled first chance exceptions specially. */
1244 if (current_event
.u
.Exception
.dwFirstChance
)
1246 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1247 (unsigned) current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1248 host_address_to_string (
1249 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
1250 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1254 last_sig
= ourstatus
->value
.sig
;
1258 /* Resume all artificially suspended threads if we are continuing
1261 windows_continue (DWORD continue_status
, int id
)
1267 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%x, %s);\n",
1268 (unsigned) current_event
.dwProcessId
,
1269 (unsigned) current_event
.dwThreadId
,
1270 continue_status
== DBG_CONTINUE
?
1271 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1273 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1274 if ((id
== -1 || id
== (int) th
->id
)
1277 if (debug_registers_changed
)
1279 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1280 th
->context
.Dr0
= dr
[0];
1281 th
->context
.Dr1
= dr
[1];
1282 th
->context
.Dr2
= dr
[2];
1283 th
->context
.Dr3
= dr
[3];
1284 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1285 th
->context
.Dr7
= dr
[7];
1287 if (th
->context
.ContextFlags
)
1289 CHECK (SetThreadContext (th
->h
, &th
->context
));
1290 th
->context
.ContextFlags
= 0;
1292 if (th
->suspended
> 0)
1293 (void) ResumeThread (th
->h
);
1297 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1298 current_event
.dwThreadId
,
1301 debug_registers_changed
= 0;
1305 /* Called in pathological case where Windows fails to send a
1306 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1308 fake_create_process (void)
1310 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1311 current_event
.dwProcessId
);
1312 if (current_process_handle
!= NULL
)
1313 open_process_used
= 1;
1316 error (_("OpenProcess call failed, GetLastError = %u"),
1317 (unsigned) GetLastError ());
1318 /* We can not debug anything in that case. */
1320 main_thread_id
= current_event
.dwThreadId
;
1321 current_thread
= windows_add_thread (
1322 ptid_build (current_event
.dwProcessId
, 0,
1323 current_event
.dwThreadId
),
1324 current_event
.u
.CreateThread
.hThread
,
1325 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1326 return main_thread_id
;
1330 windows_resume (struct target_ops
*ops
,
1331 ptid_t ptid
, int step
, enum gdb_signal sig
)
1334 DWORD continue_status
= DBG_CONTINUE
;
1336 /* A specific PTID means `step only this thread id'. */
1337 int resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1339 /* If we're continuing all threads, it's the current inferior that
1340 should be handled specially. */
1342 ptid
= inferior_ptid
;
1344 if (sig
!= GDB_SIGNAL_0
)
1346 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1348 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1350 else if (sig
== last_sig
)
1351 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1354 /* This code does not seem to work, because
1355 the kernel does probably not consider changes in the ExceptionRecord
1356 structure when passing the exception to the inferior.
1357 Note that this seems possible in the exception handler itself. */
1360 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1361 if (xlate
[i
].us
== sig
)
1363 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
1365 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1368 if (continue_status
== DBG_CONTINUE
)
1370 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1374 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1378 last_sig
= GDB_SIGNAL_0
;
1380 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1381 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, sig
));
1383 /* Get context for currently selected thread. */
1384 th
= thread_rec (ptid_get_tid (inferior_ptid
), FALSE
);
1389 /* Single step by setting t bit. */
1390 struct regcache
*regcache
= get_current_regcache ();
1391 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1392 windows_fetch_inferior_registers (ops
, regcache
,
1393 gdbarch_ps_regnum (gdbarch
));
1394 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1397 if (th
->context
.ContextFlags
)
1399 if (debug_registers_changed
)
1401 th
->context
.Dr0
= dr
[0];
1402 th
->context
.Dr1
= dr
[1];
1403 th
->context
.Dr2
= dr
[2];
1404 th
->context
.Dr3
= dr
[3];
1405 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1406 th
->context
.Dr7
= dr
[7];
1408 CHECK (SetThreadContext (th
->h
, &th
->context
));
1409 th
->context
.ContextFlags
= 0;
1413 /* Allow continuing with the same signal that interrupted us.
1414 Otherwise complain. */
1417 windows_continue (continue_status
, -1);
1419 windows_continue (continue_status
, ptid_get_tid (ptid
));
1422 /* Ctrl-C handler used when the inferior is not run in the same console. The
1423 handler is in charge of interrupting the inferior using DebugBreakProcess.
1424 Note that this function is not available prior to Windows XP. In this case
1425 we emit a warning. */
1427 ctrl_c_handler (DWORD event_type
)
1429 const int attach_flag
= current_inferior ()->attach_flag
;
1431 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1432 if (event_type
!= CTRL_C_EVENT
&& event_type
!= CTRL_BREAK_EVENT
)
1435 /* If the inferior and the debugger share the same console, do nothing as
1436 the inferior has also received the Ctrl-C event. */
1437 if (!new_console
&& !attach_flag
)
1440 if (!DebugBreakProcess (current_process_handle
))
1441 warning (_("Could not interrupt program. "
1442 "Press Ctrl-c in the program console."));
1444 /* Return true to tell that Ctrl-C has been handled. */
1448 /* Get the next event from the child. Return 1 if the event requires
1449 handling by WFI (or whatever). */
1451 get_windows_debug_event (struct target_ops
*ops
,
1452 int pid
, struct target_waitstatus
*ourstatus
)
1455 DWORD continue_status
, event_code
;
1457 static thread_info dummy_thread_info
;
1460 last_sig
= GDB_SIGNAL_0
;
1462 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1466 continue_status
= DBG_CONTINUE
;
1468 event_code
= current_event
.dwDebugEventCode
;
1469 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1471 have_saved_context
= 0;
1475 case CREATE_THREAD_DEBUG_EVENT
:
1476 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1477 (unsigned) current_event
.dwProcessId
,
1478 (unsigned) current_event
.dwThreadId
,
1479 "CREATE_THREAD_DEBUG_EVENT"));
1480 if (saw_create
!= 1)
1482 struct inferior
*inf
;
1483 inf
= find_inferior_pid (current_event
.dwProcessId
);
1484 if (!saw_create
&& inf
->attach_flag
)
1486 /* Kludge around a Windows bug where first event is a create
1487 thread event. Caused when attached process does not have
1489 retval
= fake_create_process ();
1495 /* Record the existence of this thread. */
1496 retval
= current_event
.dwThreadId
;
1497 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1498 current_event
.dwThreadId
),
1499 current_event
.u
.CreateThread
.hThread
,
1500 current_event
.u
.CreateThread
.lpThreadLocalBase
);
1504 case EXIT_THREAD_DEBUG_EVENT
:
1505 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1506 (unsigned) current_event
.dwProcessId
,
1507 (unsigned) current_event
.dwThreadId
,
1508 "EXIT_THREAD_DEBUG_EVENT"));
1510 if (current_event
.dwThreadId
!= main_thread_id
)
1512 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1513 current_event
.dwThreadId
));
1514 th
= &dummy_thread_info
;
1518 case CREATE_PROCESS_DEBUG_EVENT
:
1519 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1520 (unsigned) current_event
.dwProcessId
,
1521 (unsigned) current_event
.dwThreadId
,
1522 "CREATE_PROCESS_DEBUG_EVENT"));
1523 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1524 if (++saw_create
!= 1)
1527 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1529 windows_delete_thread (ptid_build (current_event
.dwProcessId
, 0,
1531 main_thread_id
= current_event
.dwThreadId
;
1532 /* Add the main thread. */
1533 th
= windows_add_thread (ptid_build (current_event
.dwProcessId
, 0,
1534 current_event
.dwThreadId
),
1535 current_event
.u
.CreateProcessInfo
.hThread
,
1536 current_event
.u
.CreateProcessInfo
.lpThreadLocalBase
);
1537 retval
= current_event
.dwThreadId
;
1540 case EXIT_PROCESS_DEBUG_EVENT
:
1541 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1542 (unsigned) current_event
.dwProcessId
,
1543 (unsigned) current_event
.dwThreadId
,
1544 "EXIT_PROCESS_DEBUG_EVENT"));
1545 if (!windows_initialization_done
)
1547 target_terminal_ours ();
1548 target_mourn_inferior ();
1549 error (_("During startup program exited with code 0x%x."),
1550 (unsigned int) current_event
.u
.ExitProcess
.dwExitCode
);
1552 else if (saw_create
== 1)
1554 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1555 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1556 retval
= main_thread_id
;
1560 case LOAD_DLL_DEBUG_EVENT
:
1561 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1562 (unsigned) current_event
.dwProcessId
,
1563 (unsigned) current_event
.dwThreadId
,
1564 "LOAD_DLL_DEBUG_EVENT"));
1565 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1566 if (saw_create
!= 1)
1568 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1569 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1570 ourstatus
->value
.integer
= 0;
1571 retval
= main_thread_id
;
1574 case UNLOAD_DLL_DEBUG_EVENT
:
1575 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1576 (unsigned) current_event
.dwProcessId
,
1577 (unsigned) current_event
.dwThreadId
,
1578 "UNLOAD_DLL_DEBUG_EVENT"));
1579 if (saw_create
!= 1)
1581 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1582 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1583 ourstatus
->value
.integer
= 0;
1584 retval
= main_thread_id
;
1587 case EXCEPTION_DEBUG_EVENT
:
1588 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1589 (unsigned) current_event
.dwProcessId
,
1590 (unsigned) current_event
.dwThreadId
,
1591 "EXCEPTION_DEBUG_EVENT"));
1592 if (saw_create
!= 1)
1594 switch (handle_exception (ourstatus
))
1597 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1600 retval
= current_event
.dwThreadId
;
1604 continue_status
= -1;
1609 case OUTPUT_DEBUG_STRING_EVENT
: /* Message from the kernel. */
1610 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=%x code=%s)\n",
1611 (unsigned) current_event
.dwProcessId
,
1612 (unsigned) current_event
.dwThreadId
,
1613 "OUTPUT_DEBUG_STRING_EVENT"));
1614 if (saw_create
!= 1)
1616 retval
= handle_output_debug_string (ourstatus
);
1620 if (saw_create
!= 1)
1622 printf_unfiltered ("gdb: kernel event for pid=%u tid=%x\n",
1623 (unsigned) current_event
.dwProcessId
,
1624 (unsigned) current_event
.dwThreadId
);
1625 printf_unfiltered (" unknown event code %u\n",
1626 (unsigned) current_event
.dwDebugEventCode
);
1630 if (!retval
|| saw_create
!= 1)
1632 if (continue_status
== -1)
1633 windows_resume (ops
, minus_one_ptid
, 0, 1);
1635 CHECK (windows_continue (continue_status
, -1));
1639 inferior_ptid
= ptid_build (current_event
.dwProcessId
, 0,
1641 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1648 /* Wait for interesting events to occur in the target process. */
1650 windows_wait (struct target_ops
*ops
,
1651 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
1655 target_terminal_ours ();
1657 /* We loop when we get a non-standard exception rather than return
1658 with a SPURIOUS because resume can try and step or modify things,
1659 which needs a current_thread->h. But some of these exceptions mark
1660 the birth or death of threads, which mean that the current thread
1661 isn't necessarily what you think it is. */
1667 /* If the user presses Ctrl-c while the debugger is waiting
1668 for an event, he expects the debugger to interrupt his program
1669 and to get the prompt back. There are two possible situations:
1671 - The debugger and the program do not share the console, in
1672 which case the Ctrl-c event only reached the debugger.
1673 In that case, the ctrl_c handler will take care of interrupting
1674 the inferior. Note that this case is working starting with
1675 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1678 - The debugger and the program share the same console, in which
1679 case both debugger and inferior will receive the Ctrl-c event.
1680 In that case the ctrl_c handler will ignore the event, as the
1681 Ctrl-c event generated inside the inferior will trigger the
1682 expected debug event.
1684 FIXME: brobecker/2008-05-20: If the inferior receives the
1685 signal first and the delay until GDB receives that signal
1686 is sufficiently long, GDB can sometimes receive the SIGINT
1687 after we have unblocked the CTRL+C handler. This would
1688 lead to the debugger stopping prematurely while handling
1689 the new-thread event that comes with the handling of the SIGINT
1690 inside the inferior, and then stop again immediately when
1691 the user tries to resume the execution in the inferior.
1692 This is a classic race that we should try to fix one day. */
1693 SetConsoleCtrlHandler (&ctrl_c_handler
, TRUE
);
1694 retval
= get_windows_debug_event (ops
, pid
, ourstatus
);
1695 SetConsoleCtrlHandler (&ctrl_c_handler
, FALSE
);
1698 return ptid_build (current_event
.dwProcessId
, 0, retval
);
1703 if (deprecated_ui_loop_hook
!= NULL
)
1704 detach
= deprecated_ui_loop_hook (0);
1707 windows_kill_inferior (ops
);
1713 do_initial_windows_stuff (struct target_ops
*ops
, DWORD pid
, int attaching
)
1715 extern int stop_after_trap
;
1717 struct inferior
*inf
;
1718 struct thread_info
*tp
;
1720 last_sig
= GDB_SIGNAL_0
;
1722 exception_count
= 0;
1723 open_process_used
= 0;
1724 debug_registers_changed
= 0;
1725 debug_registers_used
= 0;
1726 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1729 cygwin_load_start
= cygwin_load_end
= 0;
1731 current_event
.dwProcessId
= pid
;
1732 memset (¤t_event
, 0, sizeof (current_event
));
1734 disable_breakpoints_in_shlibs ();
1735 windows_clear_solib ();
1736 clear_proceed_status ();
1737 init_wait_for_inferior ();
1739 inf
= current_inferior ();
1740 inferior_appeared (inf
, pid
);
1741 inf
->attach_flag
= attaching
;
1743 /* Make the new process the current inferior, so terminal handling
1744 can rely on it. When attaching, we don't know about any thread
1745 id here, but that's OK --- nothing should be referencing the
1746 current thread until we report an event out of windows_wait. */
1747 inferior_ptid
= pid_to_ptid (pid
);
1749 terminal_init_inferior_with_pgrp (pid
);
1750 target_terminal_inferior ();
1752 windows_initialization_done
= 0;
1753 inf
->control
.stop_soon
= STOP_QUIETLY
;
1756 stop_after_trap
= 1;
1757 wait_for_inferior ();
1758 tp
= inferior_thread ();
1759 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_TRAP
)
1760 resume (0, tp
->suspend
.stop_signal
);
1765 windows_initialization_done
= 1;
1766 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
1767 stop_after_trap
= 0;
1771 /* Try to set or remove a user privilege to the current process. Return -1
1772 if that fails, the previous setting of that privilege otherwise.
1774 This code is copied from the Cygwin source code and rearranged to allow
1775 dynamically loading of the needed symbols from advapi32 which is only
1776 available on NT/2K/XP. */
1778 set_process_privilege (const char *privilege
, BOOL enable
)
1780 HANDLE token_hdl
= NULL
;
1782 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1786 if (!OpenProcessToken (GetCurrentProcess (),
1787 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1791 if (!LookupPrivilegeValueA (NULL
, privilege
, &restore_priv
))
1794 new_priv
.PrivilegeCount
= 1;
1795 new_priv
.Privileges
[0].Luid
= restore_priv
;
1796 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1798 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1799 sizeof orig_priv
, &orig_priv
, &size
))
1802 /* Disabled, otherwise every `attach' in an unprivileged user session
1803 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1804 windows_attach(). */
1805 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1806 be enabled. GetLastError () returns an correct error code, though. */
1807 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1811 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1815 CloseHandle (token_hdl
);
1820 /* Attach to process PID, then initialize for debugging it. */
1822 windows_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1827 pid
= parse_pid_to_attach (args
);
1829 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1831 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1832 printf_unfiltered ("This can cause attach to "
1833 "fail on Windows NT/2K/XP\n");
1836 windows_init_thread_list ();
1837 ok
= DebugActiveProcess (pid
);
1843 /* Try fall back to Cygwin pid. */
1844 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1847 ok
= DebugActiveProcess (pid
);
1852 error (_("Can't attach to process."));
1854 DebugSetProcessKillOnExit (FALSE
);
1858 char *exec_file
= (char *) get_exec_file (0);
1861 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1862 target_pid_to_str (pid_to_ptid (pid
)));
1864 printf_unfiltered ("Attaching to %s\n",
1865 target_pid_to_str (pid_to_ptid (pid
)));
1867 gdb_flush (gdb_stdout
);
1870 do_initial_windows_stuff (ops
, pid
, 1);
1871 target_terminal_ours ();
1875 windows_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1880 windows_resume (ops
, ptid
, 0, GDB_SIGNAL_0
);
1882 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1884 error (_("Can't detach process %u (error %u)"),
1885 (unsigned) current_event
.dwProcessId
, (unsigned) GetLastError ());
1888 DebugSetProcessKillOnExit (FALSE
);
1890 if (detached
&& from_tty
)
1892 char *exec_file
= get_exec_file (0);
1895 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file
,
1896 (unsigned) current_event
.dwProcessId
);
1897 gdb_flush (gdb_stdout
);
1900 i386_cleanup_dregs ();
1901 inferior_ptid
= null_ptid
;
1902 detach_inferior (current_event
.dwProcessId
);
1904 unpush_target (ops
);
1908 windows_pid_to_exec_file (int pid
)
1910 static char path
[__PMAX
];
1912 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1914 char procexe
[sizeof ("/proc/4294967295/exe")];
1916 xsnprintf (procexe
, sizeof (procexe
), "/proc/%u/exe", pid
);
1917 nchars
= readlink (procexe
, path
, sizeof(path
));
1918 if (nchars
> 0 && nchars
< sizeof (path
))
1920 path
[nchars
] = '\0'; /* Got it */
1925 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1926 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1927 if (!get_module_name (0, path
))
1933 /* Print status information about what we're accessing. */
1936 windows_files_info (struct target_ops
*ignore
)
1938 struct inferior
*inf
= current_inferior ();
1940 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1941 inf
->attach_flag
? "attached" : "child",
1942 target_pid_to_str (inferior_ptid
));
1946 windows_open (char *arg
, int from_tty
)
1948 error (_("Use the \"run\" command to start a Unix child process."));
1951 /* Modify CreateProcess parameters for use of a new separate console.
1953 *FLAGS: DWORD parameter for general process creation flags.
1954 *SI: STARTUPINFO structure, for which the console window size and
1955 console buffer size is filled in if GDB is running in a console.
1956 to create the new console.
1957 The size of the used font is not available on all versions of
1958 Windows OS. Furthermore, the current font might not be the default
1959 font, but this is still better than before.
1960 If the windows and buffer sizes are computed,
1961 SI->DWFLAGS is changed so that this information is used
1962 by CreateProcess function. */
1965 windows_set_console_info (STARTUPINFO
*si
, DWORD
*flags
)
1967 HANDLE hconsole
= CreateFile ("CONOUT$", GENERIC_READ
| GENERIC_WRITE
,
1968 FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1970 if (hconsole
!= INVALID_HANDLE_VALUE
)
1972 CONSOLE_SCREEN_BUFFER_INFO sbinfo
;
1974 CONSOLE_FONT_INFO cfi
;
1976 GetCurrentConsoleFont (hconsole
, FALSE
, &cfi
);
1977 font_size
= GetConsoleFontSize (hconsole
, cfi
.nFont
);
1978 GetConsoleScreenBufferInfo(hconsole
, &sbinfo
);
1979 si
->dwXSize
= sbinfo
.srWindow
.Right
- sbinfo
.srWindow
.Left
+ 1;
1980 si
->dwYSize
= sbinfo
.srWindow
.Bottom
- sbinfo
.srWindow
.Top
+ 1;
1982 si
->dwXSize
*= font_size
.X
;
1986 si
->dwYSize
*= font_size
.Y
;
1989 si
->dwXCountChars
= sbinfo
.dwSize
.X
;
1990 si
->dwYCountChars
= sbinfo
.dwSize
.Y
;
1991 si
->dwFlags
|= STARTF_USESIZE
| STARTF_USECOUNTCHARS
;
1993 *flags
|= CREATE_NEW_CONSOLE
;
1997 /* Function called by qsort to sort environment strings. */
2000 envvar_cmp (const void *a
, const void *b
)
2002 const char **p
= (const char **) a
;
2003 const char **q
= (const char **) b
;
2004 return strcasecmp (*p
, *q
);
2010 clear_win32_environment (char **env
)
2014 wchar_t *copy
= NULL
, *equalpos
;
2016 for (i
= 0; env
[i
] && *env
[i
]; i
++)
2018 len
= mbstowcs (NULL
, env
[i
], 0) + 1;
2019 copy
= (wchar_t *) xrealloc (copy
, len
* sizeof (wchar_t));
2020 mbstowcs (copy
, env
[i
], len
);
2021 equalpos
= wcschr (copy
, L
'=');
2024 SetEnvironmentVariableW (copy
, NULL
);
2030 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2031 EXEC_FILE is the file to run.
2032 ALLARGS is a string containing the arguments to the program.
2033 ENV is the environment vector to pass. Errors reported with error(). */
2036 windows_create_inferior (struct target_ops
*ops
, char *exec_file
,
2037 char *allargs
, char **in_env
, int from_tty
)
2041 cygwin_buf_t real_path
[__PMAX
];
2042 cygwin_buf_t shell
[__PMAX
]; /* Path to shell */
2044 cygwin_buf_t
*toexec
;
2045 cygwin_buf_t
*cygallargs
;
2047 char **old_env
= NULL
;
2051 int ostdin
, ostdout
, ostderr
;
2053 char real_path
[__PMAX
];
2054 char shell
[__PMAX
]; /* Path to shell */
2066 PROCESS_INFORMATION pi
;
2069 const char *inferior_io_terminal
= get_inferior_io_terminal ();
2072 error (_("No executable specified, use `target exec'."));
2074 memset (&si
, 0, sizeof (si
));
2075 si
.cb
= sizeof (si
);
2078 flags
|= CREATE_NEW_PROCESS_GROUP
;
2081 windows_set_console_info (&si
, &flags
);
2086 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2087 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, exec_file
, real_path
,
2088 __PMAX
* sizeof (cygwin_buf_t
)) < 0)
2089 error (_("Error starting executable: %d"), errno
);
2092 len
= mbstowcs (NULL
, allargs
, 0) + 1;
2093 if (len
== (size_t) -1)
2094 error (_("Error starting executable: %d"), errno
);
2095 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2096 mbstowcs (cygallargs
, allargs
, len
);
2098 cygallargs
= allargs
;
2103 sh
= getenv ("SHELL");
2106 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W
, sh
, shell
, __PMAX
) < 0)
2107 error (_("Error starting executable via shell: %d"), errno
);
2109 len
= sizeof (L
" -c 'exec '") + mbstowcs (NULL
, exec_file
, 0)
2110 + mbstowcs (NULL
, allargs
, 0) + 2;
2111 cygallargs
= (wchar_t *) alloca (len
* sizeof (wchar_t));
2112 swprintf (cygallargs
, len
, L
" -c 'exec %s %s'", exec_file
, allargs
);
2114 len
= (sizeof (" -c 'exec '") + strlen (exec_file
)
2115 + strlen (allargs
) + 2);
2116 cygallargs
= (char *) alloca (len
);
2117 xsnprintf (cygallargs
, len
, " -c 'exec %s %s'", exec_file
, allargs
);
2120 flags
|= DEBUG_PROCESS
;
2124 args
= (cygwin_buf_t
*) alloca ((wcslen (toexec
) + wcslen (cygallargs
) + 2)
2125 * sizeof (wchar_t));
2126 wcscpy (args
, toexec
);
2127 wcscat (args
, L
" ");
2128 wcscat (args
, cygallargs
);
2130 args
= (cygwin_buf_t
*) alloca (strlen (toexec
) + strlen (cygallargs
) + 2);
2131 strcpy (args
, toexec
);
2133 strcat (args
, cygallargs
);
2136 #ifdef CW_CVT_ENV_TO_WINENV
2137 /* First try to create a direct Win32 copy of the POSIX environment. */
2138 w32_env
= (PWCHAR
) cygwin_internal (CW_CVT_ENV_TO_WINENV
, in_env
);
2139 if (w32_env
!= (PWCHAR
) -1)
2140 flags
|= CREATE_UNICODE_ENVIRONMENT
;
2142 /* If that fails, fall back to old method tweaking GDB's environment. */
2145 /* Reset all Win32 environment variables to avoid leftover on next run. */
2146 clear_win32_environment (environ
);
2147 /* Prepare the environment vars for CreateProcess. */
2150 cygwin_internal (CW_SYNC_WINENV
);
2154 if (!inferior_io_terminal
)
2155 tty
= ostdin
= ostdout
= ostderr
= -1;
2158 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2161 print_sys_errmsg (inferior_io_terminal
, errno
);
2162 ostdin
= ostdout
= ostderr
= -1;
2175 windows_init_thread_list ();
2176 ret
= CreateProcess (0,
2177 args
, /* command line */
2178 NULL
, /* Security */
2180 TRUE
, /* inherit handles */
2181 flags
, /* start flags */
2182 w32_env
, /* environment */
2183 NULL
, /* current directory */
2187 /* Just free the Win32 environment, if it could be created. */
2191 /* Reset all environment variables to avoid leftover on next run. */
2192 clear_win32_environment (in_env
);
2193 /* Restore normal GDB environment variables. */
2195 cygwin_internal (CW_SYNC_WINENV
);
2210 /* Build the command line, a space-separated list of tokens where
2211 the first token is the name of the module to be executed.
2212 To avoid ambiguities introduced by spaces in the module name,
2214 args_len
= strlen (toexec
) + 2 /* quotes */ + strlen (allargs
) + 2;
2215 args
= alloca (args_len
);
2216 xsnprintf (args
, args_len
, "\"%s\" %s", toexec
, allargs
);
2218 flags
|= DEBUG_ONLY_THIS_PROCESS
;
2220 if (!inferior_io_terminal
)
2221 tty
= INVALID_HANDLE_VALUE
;
2224 SECURITY_ATTRIBUTES sa
;
2225 sa
.nLength
= sizeof(sa
);
2226 sa
.lpSecurityDescriptor
= 0;
2227 sa
.bInheritHandle
= TRUE
;
2228 tty
= CreateFileA (inferior_io_terminal
, GENERIC_READ
| GENERIC_WRITE
,
2229 0, &sa
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, 0);
2230 if (tty
== INVALID_HANDLE_VALUE
)
2231 warning (_("Warning: Failed to open TTY %s, error %#x."),
2232 inferior_io_terminal
, (unsigned) GetLastError ());
2236 si
.hStdOutput
= tty
;
2238 si
.dwFlags
|= STARTF_USESTDHANDLES
;
2242 /* CreateProcess takes the environment list as a null terminated set of
2243 strings (i.e. two nulls terminate the list). */
2245 /* Get total size for env strings. */
2246 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
2247 envlen
+= strlen (in_env
[i
]) + 1;
2249 envsize
= sizeof (in_env
[0]) * (i
+ 1);
2250 env
= (char **) alloca (envsize
);
2251 memcpy (env
, in_env
, envsize
);
2252 /* Windows programs expect the environment block to be sorted. */
2253 qsort (env
, i
, sizeof (char *), envvar_cmp
);
2255 w32env
= alloca (envlen
+ 1);
2257 /* Copy env strings into new buffer. */
2258 for (temp
= w32env
, i
= 0; env
[i
] && *env
[i
]; i
++)
2260 strcpy (temp
, env
[i
]);
2261 temp
+= strlen (temp
) + 1;
2264 /* Final nil string to terminate new env. */
2267 windows_init_thread_list ();
2268 ret
= CreateProcessA (0,
2269 args
, /* command line */
2270 NULL
, /* Security */
2272 TRUE
, /* inherit handles */
2273 flags
, /* start flags */
2274 w32env
, /* environment */
2275 NULL
, /* current directory */
2278 if (tty
!= INVALID_HANDLE_VALUE
)
2283 error (_("Error creating process %s, (error %u)."),
2284 exec_file
, (unsigned) GetLastError ());
2286 CloseHandle (pi
.hThread
);
2287 CloseHandle (pi
.hProcess
);
2289 if (useshell
&& shell
[0] != '\0')
2294 do_initial_windows_stuff (ops
, pi
.dwProcessId
, 0);
2296 /* windows_continue (DBG_CONTINUE, -1); */
2300 windows_mourn_inferior (struct target_ops
*ops
)
2302 (void) windows_continue (DBG_CONTINUE
, -1);
2303 i386_cleanup_dregs();
2304 if (open_process_used
)
2306 CHECK (CloseHandle (current_process_handle
));
2307 open_process_used
= 0;
2309 unpush_target (ops
);
2310 generic_mourn_inferior ();
2313 /* Send a SIGINT to the process group. This acts just like the user typed a
2314 ^C on the controlling terminal. */
2317 windows_stop (ptid_t ptid
)
2319 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2320 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2321 registers_changed (); /* refresh register state */
2325 windows_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2326 int write
, struct mem_attrib
*mem
,
2327 struct target_ops
*target
)
2332 DEBUG_MEM (("gdb: write target memory, %d bytes at %s\n",
2333 len
, core_addr_to_string (memaddr
)));
2334 if (!WriteProcessMemory (current_process_handle
,
2335 (LPVOID
) (uintptr_t) memaddr
, our
,
2338 FlushInstructionCache (current_process_handle
,
2339 (LPCVOID
) (uintptr_t) memaddr
, len
);
2343 DEBUG_MEM (("gdb: read target memory, %d bytes at %s\n",
2344 len
, core_addr_to_string (memaddr
)));
2345 if (!ReadProcessMemory (current_process_handle
,
2346 (LPCVOID
) (uintptr_t) memaddr
, our
,
2354 windows_kill_inferior (struct target_ops
*ops
)
2356 CHECK (TerminateProcess (current_process_handle
, 0));
2360 if (!windows_continue (DBG_CONTINUE
, -1))
2362 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2364 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2368 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2372 windows_prepare_to_store (struct regcache
*regcache
)
2374 /* Do nothing, since we can store individual regs. */
2378 windows_can_run (void)
2384 windows_close (void)
2386 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2387 PIDGET (inferior_ptid
)));
2390 /* Convert pid to printable format. */
2392 windows_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2394 static char buf
[80];
2396 if (ptid_get_tid (ptid
) != 0)
2398 snprintf (buf
, sizeof (buf
), "Thread %d.0x%lx",
2399 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
2403 return normal_pid_to_str (ptid
);
2407 windows_xfer_shared_libraries (struct target_ops
*ops
,
2408 enum target_object object
, const char *annex
,
2409 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2410 ULONGEST offset
, LONGEST len
)
2412 struct obstack obstack
;
2420 obstack_init (&obstack
);
2421 obstack_grow_str (&obstack
, "<library-list>\n");
2422 for (so
= solib_start
.next
; so
; so
= so
->next
)
2423 windows_xfer_shared_library (so
->so_name
, (CORE_ADDR
)
2424 (uintptr_t) so
->lm_info
->load_addr
,
2425 target_gdbarch (), &obstack
);
2426 obstack_grow_str0 (&obstack
, "</library-list>\n");
2428 buf
= obstack_finish (&obstack
);
2429 len_avail
= strlen (buf
);
2430 if (offset
>= len_avail
)
2434 if (len
> len_avail
- offset
)
2435 len
= len_avail
- offset
;
2436 memcpy (readbuf
, buf
+ offset
, len
);
2439 obstack_free (&obstack
, NULL
);
2444 windows_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2445 const char *annex
, gdb_byte
*readbuf
,
2446 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2450 case TARGET_OBJECT_MEMORY
:
2452 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2453 len
, 0/*read*/, NULL
, ops
);
2455 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2456 len
, 1/*write*/, NULL
, ops
);
2459 case TARGET_OBJECT_LIBRARIES
:
2460 return windows_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2461 writebuf
, offset
, len
);
2464 if (ops
->beneath
!= NULL
)
2465 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2466 readbuf
, writebuf
, offset
, len
);
2471 /* Provide thread local base, i.e. Thread Information Block address.
2472 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2475 windows_get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
2479 th
= thread_rec (ptid_get_tid (ptid
), 0);
2484 *addr
= th
->thread_local_base
;
2490 windows_get_ada_task_ptid (long lwp
, long thread
)
2492 return ptid_build (ptid_get_pid (inferior_ptid
), 0, lwp
);
2496 init_windows_ops (void)
2498 windows_ops
.to_shortname
= "child";
2499 windows_ops
.to_longname
= "Win32 child process";
2500 windows_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2501 windows_ops
.to_open
= windows_open
;
2502 windows_ops
.to_close
= windows_close
;
2503 windows_ops
.to_attach
= windows_attach
;
2504 windows_ops
.to_attach_no_wait
= 1;
2505 windows_ops
.to_detach
= windows_detach
;
2506 windows_ops
.to_resume
= windows_resume
;
2507 windows_ops
.to_wait
= windows_wait
;
2508 windows_ops
.to_fetch_registers
= windows_fetch_inferior_registers
;
2509 windows_ops
.to_store_registers
= windows_store_inferior_registers
;
2510 windows_ops
.to_prepare_to_store
= windows_prepare_to_store
;
2511 windows_ops
.deprecated_xfer_memory
= windows_xfer_memory
;
2512 windows_ops
.to_xfer_partial
= windows_xfer_partial
;
2513 windows_ops
.to_files_info
= windows_files_info
;
2514 windows_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2515 windows_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2516 windows_ops
.to_terminal_init
= terminal_init_inferior
;
2517 windows_ops
.to_terminal_inferior
= terminal_inferior
;
2518 windows_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2519 windows_ops
.to_terminal_ours
= terminal_ours
;
2520 windows_ops
.to_terminal_save_ours
= terminal_save_ours
;
2521 windows_ops
.to_terminal_info
= child_terminal_info
;
2522 windows_ops
.to_kill
= windows_kill_inferior
;
2523 windows_ops
.to_create_inferior
= windows_create_inferior
;
2524 windows_ops
.to_mourn_inferior
= windows_mourn_inferior
;
2525 windows_ops
.to_can_run
= windows_can_run
;
2526 windows_ops
.to_thread_alive
= windows_thread_alive
;
2527 windows_ops
.to_pid_to_str
= windows_pid_to_str
;
2528 windows_ops
.to_stop
= windows_stop
;
2529 windows_ops
.to_stratum
= process_stratum
;
2530 windows_ops
.to_has_all_memory
= default_child_has_all_memory
;
2531 windows_ops
.to_has_memory
= default_child_has_memory
;
2532 windows_ops
.to_has_stack
= default_child_has_stack
;
2533 windows_ops
.to_has_registers
= default_child_has_registers
;
2534 windows_ops
.to_has_execution
= default_child_has_execution
;
2535 windows_ops
.to_pid_to_exec_file
= windows_pid_to_exec_file
;
2536 windows_ops
.to_get_ada_task_ptid
= windows_get_ada_task_ptid
;
2537 windows_ops
.to_get_tib_address
= windows_get_tib_address
;
2539 i386_use_watchpoints (&windows_ops
);
2541 i386_dr_low
.set_control
= cygwin_set_dr7
;
2542 i386_dr_low
.set_addr
= cygwin_set_dr
;
2543 i386_dr_low
.get_addr
= cygwin_get_dr
;
2544 i386_dr_low
.get_status
= cygwin_get_dr6
;
2545 i386_dr_low
.get_control
= cygwin_get_dr7
;
2547 /* i386_dr_low.debug_register_length field is set by
2548 calling i386_set_debug_register_length function
2549 in processor windows specific native file. */
2551 windows_ops
.to_magic
= OPS_MAGIC
;
2555 set_windows_aliases (char *argv0
)
2557 add_info_alias ("dll", "sharedlibrary", 1);
2560 /* -Wmissing-prototypes */
2561 extern initialize_file_ftype _initialize_windows_nat
;
2564 _initialize_windows_nat (void)
2566 struct cmd_list_element
*c
;
2568 init_windows_ops ();
2571 cygwin_internal (CW_SET_DOS_FILE_WARNING
, 0);
2574 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2575 _("Load dll library symbols from FILE."));
2576 set_cmd_completer (c
, filename_completer
);
2578 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2580 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias
, 1);
2582 add_com_alias ("assf", "dll-symbols", class_alias
, 1);
2585 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2586 Set use of shell to start subprocess."), _("\
2587 Show use of shell to start subprocess."), NULL
,
2589 NULL
, /* FIXME: i18n: */
2590 &setlist
, &showlist
);
2592 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
,
2593 &cygwin_exceptions
, _("\
2594 Break when an exception is detected in the Cygwin DLL itself."), _("\
2595 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2597 NULL
, /* FIXME: i18n: */
2598 &setlist
, &showlist
);
2601 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2602 Set creation of new console when creating child process."), _("\
2603 Show creation of new console when creating child process."), NULL
,
2605 NULL
, /* FIXME: i18n: */
2606 &setlist
, &showlist
);
2608 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2609 Set creation of new group when creating child process."), _("\
2610 Show creation of new group when creating child process."), NULL
,
2612 NULL
, /* FIXME: i18n: */
2613 &setlist
, &showlist
);
2615 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2616 Set whether to display execution in child process."), _("\
2617 Show whether to display execution in child process."), NULL
,
2619 NULL
, /* FIXME: i18n: */
2620 &setlist
, &showlist
);
2622 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2623 Set whether to display kernel events in child process."), _("\
2624 Show whether to display kernel events in child process."), NULL
,
2626 NULL
, /* FIXME: i18n: */
2627 &setlist
, &showlist
);
2629 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2630 Set whether to display memory accesses in child process."), _("\
2631 Show whether to display memory accesses in child process."), NULL
,
2633 NULL
, /* FIXME: i18n: */
2634 &setlist
, &showlist
);
2636 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2637 &debug_exceptions
, _("\
2638 Set whether to display kernel exceptions in child process."), _("\
2639 Show whether to display kernel exceptions in child process."), NULL
,
2641 NULL
, /* FIXME: i18n: */
2642 &setlist
, &showlist
);
2644 init_w32_command_list ();
2646 add_cmd ("selector", class_info
, display_selectors
,
2647 _("Display selectors infos."),
2649 add_target (&windows_ops
);
2650 deprecated_init_ui_hook
= set_windows_aliases
;
2653 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2655 /* Pass the address ADDR to the inferior in the I'th debug register.
2656 Here we just store the address in dr array, the registers will be
2657 actually set up when windows_continue is called. */
2659 cygwin_set_dr (int i
, CORE_ADDR addr
)
2662 internal_error (__FILE__
, __LINE__
,
2663 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2665 debug_registers_changed
= 1;
2666 debug_registers_used
= 1;
2669 /* Pass the value VAL to the inferior in the DR7 debug control
2670 register. Here we just store the address in D_REGS, the watchpoint
2671 will be actually set up in windows_wait. */
2673 cygwin_set_dr7 (unsigned long val
)
2675 dr
[7] = (CORE_ADDR
) val
;
2676 debug_registers_changed
= 1;
2677 debug_registers_used
= 1;
2680 /* Get the value of debug register I from the inferior. */
2683 cygwin_get_dr (int i
)
2688 /* Get the value of the DR6 debug status register from the inferior.
2689 Here we just return the value stored in dr[6]
2690 by the last call to thread_rec for current_event.dwThreadId id. */
2691 static unsigned long
2692 cygwin_get_dr6 (void)
2694 return (unsigned long) dr
[6];
2697 /* Get the value of the DR7 debug status register from the inferior.
2698 Here we just return the value stored in dr[7] by the last call to
2699 thread_rec for current_event.dwThreadId id. */
2701 static unsigned long
2702 cygwin_get_dr7 (void)
2704 return (unsigned long) dr
[7];
2707 /* Determine if the thread referenced by "ptid" is alive
2708 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2709 it means that the thread has died. Otherwise it is assumed to be alive. */
2711 windows_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2715 gdb_assert (ptid_get_tid (ptid
) != 0);
2716 tid
= ptid_get_tid (ptid
);
2718 return WaitForSingleObject (thread_rec (tid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
2722 /* -Wmissing-prototypes */
2723 extern initialize_file_ftype _initialize_check_for_gdb_ini
;
2726 _initialize_check_for_gdb_ini (void)
2729 if (inhibit_gdbinit
)
2732 homedir
= getenv ("HOME");
2736 char *oldini
= (char *) alloca (strlen (homedir
) +
2737 sizeof ("/gdb.ini"));
2738 strcpy (oldini
, homedir
);
2739 p
= strchr (oldini
, '\0');
2740 if (p
> oldini
&& !IS_DIR_SEPARATOR (p
[-1]))
2742 strcpy (p
, "gdb.ini");
2743 if (access (oldini
, 0) == 0)
2745 int len
= strlen (oldini
);
2746 char *newini
= alloca (len
+ 1);
2748 xsnprintf (newini
, len
+ 1, "%.*s.gdbinit",
2749 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2750 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);
2755 /* Define dummy functions which always return error for the rare cases where
2756 these functions could not be found. */
2758 bad_DebugActiveProcessStop (DWORD w
)
2763 bad_DebugBreakProcess (HANDLE w
)
2768 bad_DebugSetProcessKillOnExit (BOOL w
)
2773 bad_EnumProcessModules (HANDLE w
, HMODULE
*x
, DWORD y
, LPDWORD z
)
2780 bad_GetModuleFileNameExW (HANDLE w
, HMODULE x
, LPWSTR y
, DWORD z
)
2786 bad_GetModuleFileNameExA (HANDLE w
, HMODULE x
, LPSTR y
, DWORD z
)
2793 bad_GetModuleInformation (HANDLE w
, HMODULE x
, LPMODULEINFO y
, DWORD z
)
2799 bad_OpenProcessToken (HANDLE w
, DWORD x
, PHANDLE y
)
2805 bad_GetCurrentConsoleFont (HANDLE w
, BOOL bMaxWindow
, CONSOLE_FONT_INFO
*f
)
2811 bad_GetConsoleFontSize (HANDLE w
, DWORD nFont
)
2819 /* -Wmissing-prototypes */
2820 extern initialize_file_ftype _initialize_loadable
;
2822 /* Load any functions which may not be available in ancient versions
2826 _initialize_loadable (void)
2830 hm
= LoadLibrary ("kernel32.dll");
2833 DebugActiveProcessStop
= (void *)
2834 GetProcAddress (hm
, "DebugActiveProcessStop");
2835 DebugBreakProcess
= (void *)
2836 GetProcAddress (hm
, "DebugBreakProcess");
2837 DebugSetProcessKillOnExit
= (void *)
2838 GetProcAddress (hm
, "DebugSetProcessKillOnExit");
2839 GetConsoleFontSize
= (void *)
2840 GetProcAddress (hm
, "GetConsoleFontSize");
2841 GetCurrentConsoleFont
= (void *)
2842 GetProcAddress (hm
, "GetCurrentConsoleFont");
2845 /* Set variables to dummy versions of these processes if the function
2846 wasn't found in kernel32.dll. */
2847 if (!DebugBreakProcess
)
2848 DebugBreakProcess
= bad_DebugBreakProcess
;
2849 if (!DebugActiveProcessStop
|| !DebugSetProcessKillOnExit
)
2851 DebugActiveProcessStop
= bad_DebugActiveProcessStop
;
2852 DebugSetProcessKillOnExit
= bad_DebugSetProcessKillOnExit
;
2854 if (!GetConsoleFontSize
)
2855 GetConsoleFontSize
= bad_GetConsoleFontSize
;
2856 if (!GetCurrentConsoleFont
)
2857 GetCurrentConsoleFont
= bad_GetCurrentConsoleFont
;
2859 /* Load optional functions used for retrieving filename information
2860 associated with the currently debugged process or its dlls. */
2861 hm
= LoadLibrary ("psapi.dll");
2864 EnumProcessModules
= (void *)
2865 GetProcAddress (hm
, "EnumProcessModules");
2866 GetModuleInformation
= (void *)
2867 GetProcAddress (hm
, "GetModuleInformation");
2868 GetModuleFileNameEx
= (void *)
2869 GetProcAddress (hm
, GetModuleFileNameEx_name
);
2872 if (!EnumProcessModules
|| !GetModuleInformation
|| !GetModuleFileNameEx
)
2874 /* Set variables to dummy versions of these processes if the function
2875 wasn't found in psapi.dll. */
2876 EnumProcessModules
= bad_EnumProcessModules
;
2877 GetModuleInformation
= bad_GetModuleInformation
;
2878 GetModuleFileNameEx
= bad_GetModuleFileNameEx
;
2879 /* This will probably fail on Windows 9x/Me. Let the user know
2880 that we're missing some functionality. */
2882 cannot automatically find executable file or library to read symbols.\n\
2883 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2886 hm
= LoadLibrary ("advapi32.dll");
2889 OpenProcessToken
= (void *) GetProcAddress (hm
, "OpenProcessToken");
2890 LookupPrivilegeValueA
= (void *)
2891 GetProcAddress (hm
, "LookupPrivilegeValueA");
2892 AdjustTokenPrivileges
= (void *)
2893 GetProcAddress (hm
, "AdjustTokenPrivileges");
2894 /* Only need to set one of these since if OpenProcessToken fails nothing
2896 if (!OpenProcessToken
|| !LookupPrivilegeValueA
2897 || !AdjustTokenPrivileges
)
2898 OpenProcessToken
= bad_OpenProcessToken
;