X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fwindows-nat.c;h=6a5a295ad16b91a6d64346797d5e5c1afa16ae80;hb=7ef3addbe195b6283d0baf59e081146dfb211c97;hp=6e62dfe3c681510f022b3c7c5ccb25aa5d64d9f9;hpb=51a9c8c5f8931d601a67494e8a65450083b35f92;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c index 6e62dfe3c6..6a5a295ad1 100644 --- a/gdb/windows-nat.c +++ b/gdb/windows-nat.c @@ -1,6 +1,6 @@ /* Target-vector operations for controlling windows child processes, for GDB. - Copyright (C) 1995-2014 Free Software Foundation, Inc. + Copyright (C) 1995-2017 Free Software Foundation, Inc. Contributed by Cygnus Solutions, A Red Hat Company. @@ -24,8 +24,8 @@ #include "defs.h" #include "frame.h" /* required by inferior.h */ #include "inferior.h" +#include "infrun.h" #include "target.h" -#include "exceptions.h" #include "gdbcore.h" #include "command.h" #include "completer.h" @@ -34,7 +34,6 @@ #include #include #include -#include #include #include #include @@ -50,7 +49,6 @@ #include "objfiles.h" #include "gdb_bfd.h" #include "gdb_obstack.h" -#include #include "gdbthread.h" #include "gdbcmd.h" #include @@ -58,13 +56,14 @@ #include "solist.h" #include "solib.h" #include "xml-support.h" +#include "inttypes.h" #include "i386-tdep.h" #include "i387-tdep.h" #include "windows-tdep.h" #include "windows-nat.h" -#include "i386-nat.h" +#include "x86-nat.h" #include "complaints.h" #include "inf-child.h" @@ -79,20 +78,41 @@ #define GetConsoleFontSize dyn_GetConsoleFontSize #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont -static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES, - DWORD, PTOKEN_PRIVILEGES, PDWORD); -static BOOL WINAPI (*DebugActiveProcessStop) (DWORD); -static BOOL WINAPI (*DebugBreakProcess) (HANDLE); -static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL); -static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD, - LPDWORD); -static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, - DWORD); -static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID); -static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE); -static BOOL WINAPI (*GetCurrentConsoleFont) (HANDLE, BOOL, - CONSOLE_FONT_INFO *); -static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD); +typedef BOOL WINAPI (AdjustTokenPrivileges_ftype) (HANDLE, BOOL, + PTOKEN_PRIVILEGES, + DWORD, PTOKEN_PRIVILEGES, + PDWORD); +static AdjustTokenPrivileges_ftype *AdjustTokenPrivileges; + +typedef BOOL WINAPI (DebugActiveProcessStop_ftype) (DWORD); +static DebugActiveProcessStop_ftype *DebugActiveProcessStop; + +typedef BOOL WINAPI (DebugBreakProcess_ftype) (HANDLE); +static DebugBreakProcess_ftype *DebugBreakProcess; + +typedef BOOL WINAPI (DebugSetProcessKillOnExit_ftype) (BOOL); +static DebugSetProcessKillOnExit_ftype *DebugSetProcessKillOnExit; + +typedef BOOL WINAPI (EnumProcessModules_ftype) (HANDLE, HMODULE *, DWORD, + LPDWORD); +static EnumProcessModules_ftype *EnumProcessModules; + +typedef BOOL WINAPI (GetModuleInformation_ftype) (HANDLE, HMODULE, + LPMODULEINFO, DWORD); +static GetModuleInformation_ftype *GetModuleInformation; + +typedef BOOL WINAPI (LookupPrivilegeValueA_ftype) (LPCSTR, LPCSTR, PLUID); +static LookupPrivilegeValueA_ftype *LookupPrivilegeValueA; + +typedef BOOL WINAPI (OpenProcessToken_ftype) (HANDLE, DWORD, PHANDLE); +static OpenProcessToken_ftype *OpenProcessToken; + +typedef BOOL WINAPI (GetCurrentConsoleFont_ftype) (HANDLE, BOOL, + CONSOLE_FONT_INFO *); +static GetCurrentConsoleFont_ftype *GetCurrentConsoleFont; + +typedef COORD WINAPI (GetConsoleFontSize_ftype) (HANDLE, DWORD); +static GetConsoleFontSize_ftype *GetConsoleFontSize; #undef STARTUPINFO #undef CreateProcess @@ -100,7 +120,8 @@ static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD); #ifndef __CYGWIN__ # define __PMAX (MAX_PATH + 1) - static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD); + typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, LPSTR, DWORD); + static GetModuleFileNameEx_ftype *GetModuleFileNameEx; # define STARTUPINFO STARTUPINFOA # define CreateProcess CreateProcessA # define GetModuleFileNameEx_name "GetModuleFileNameExA" @@ -112,8 +133,9 @@ static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD); static CORE_ADDR cygwin_load_end; # define __USEWIDE typedef wchar_t cygwin_buf_t; - static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, - LPWSTR, DWORD); + typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, + LPWSTR, DWORD); + static GetModuleFileNameEx_ftype *GetModuleFileNameEx; # define STARTUPINFO STARTUPINFOW # define CreateProcess CreateProcessW # define GetModuleFileNameEx_name "GetModuleFileNameExW" @@ -132,7 +154,6 @@ static CONTEXT saved_context; /* Containes the saved context from a enum { FLAG_TRACE_BIT = 0x100, - CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT) }; #endif @@ -142,8 +163,9 @@ enum #define CONTEXT_EXTENDED_REGISTERS 0 #endif -#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \ - | CONTEXT_EXTENDED_REGISTERS +#define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \ + | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \ + | CONTEXT_EXTENDED_REGISTERS static uintptr_t dr[8]; static int debug_registers_changed; @@ -152,6 +174,19 @@ static int debug_registers_used; static int windows_initialization_done; #define DR6_CLEAR_VALUE 0xffff0ff0 +/* The exception thrown by a program to tell the debugger the name of + a thread. The exception record contains an ID of a thread and a + name to give it. This exception has no documented name, but MSDN + dubs it "MS_VC_EXCEPTION" in one code example. */ +#define MS_VC_EXCEPTION 0x406d1388 + +typedef enum +{ + HANDLE_EXCEPTION_UNHANDLED = 0, + HANDLE_EXCEPTION_HANDLED, + HANDLE_EXCEPTION_IGNORED +} handle_exception_result; + /* The string sent by cygwin when it processes a signal. FIXME: This should be in a cygwin include file. */ #ifndef _CYGWIN_SIGNAL_STRING @@ -164,7 +199,7 @@ static int windows_initialization_done; #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x -static void windows_stop (struct target_ops *self, ptid_t); +static void windows_interrupt (struct target_ops *self, ptid_t); static int windows_thread_alive (struct target_ops *, ptid_t); static void windows_kill_inferior (struct target_ops *); @@ -179,9 +214,9 @@ static enum gdb_signal last_sig = GDB_SIGNAL_0; /* Thread information structure used to track information that is not available in gdb's thread structure. */ -typedef struct thread_info_struct +typedef struct windows_thread_info_struct { - struct thread_info_struct *next; + struct windows_thread_info_struct *next; DWORD id; HANDLE h; CORE_ADDR thread_local_base; @@ -191,16 +226,16 @@ typedef struct thread_info_struct CONTEXT context; STACKFRAME sf; } -thread_info; +windows_thread_info; -static thread_info thread_head; +static windows_thread_info thread_head; /* The process and thread handles for the above context. */ static DEBUG_EVENT current_event; /* The current debug event from WaitForDebugEvent */ static HANDLE current_process_handle; /* Currently executing process */ -static thread_info *current_thread; /* Info on currently selected thread */ +static windows_thread_info *current_thread; /* Info on currently selected thread */ static DWORD main_thread_id; /* Thread ID of the main thread */ /* Counts of things. */ @@ -263,7 +298,7 @@ static const struct xlate_exception {DBG_CONTROL_C, GDB_SIGNAL_INT}, {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP}, {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE}, - {-1, -1}}; + {-1, GDB_SIGNAL_UNKNOWN}}; /* Set the MAPPINGS static global to OFFSETS. See the description of MAPPINGS for more details. */ @@ -293,10 +328,10 @@ check (BOOL ok, const char *file, int line) /* Find a thread record given a thread id. If GET_CONTEXT is not 0, then also retrieve the context for this thread. If GET_CONTEXT is negative, then don't suspend the thread. */ -static thread_info * +static windows_thread_info * thread_rec (DWORD id, int get_context) { - thread_info *th; + windows_thread_info *th; for (th = &thread_head; (th = th->next) != NULL;) if (th->id == id) @@ -309,12 +344,21 @@ thread_rec (DWORD id, int get_context) { DWORD err = GetLastError (); - warning (_("SuspendThread (tid=0x%x) failed." - " (winerr %u)"), - (unsigned) id, (unsigned) err); - return NULL; + /* We get Access Denied (5) when trying to suspend + threads that Windows started on behalf of the + debuggee, usually when those threads are just + about to exit. + We can get Invalid Handle (6) if the main thread + has exited. */ + if (err != ERROR_INVALID_HANDLE + && err != ERROR_ACCESS_DENIED) + warning (_("SuspendThread (tid=0x%x) failed." + " (winerr %u)"), + (unsigned) id, (unsigned) err); + th->suspended = -1; } - th->suspended = 1; + else + th->suspended = 1; } else if (get_context < 0) th->suspended = -1; @@ -327,10 +371,10 @@ thread_rec (DWORD id, int get_context) } /* Add a thread to the thread list. */ -static thread_info * +static windows_thread_info * windows_add_thread (ptid_t ptid, HANDLE h, void *tlb) { - thread_info *th; + windows_thread_info *th; DWORD id; gdb_assert (ptid_get_tid (ptid) != 0); @@ -340,7 +384,7 @@ windows_add_thread (ptid_t ptid, HANDLE h, void *tlb) if ((th = thread_rec (id, FALSE))) return th; - th = XCNEW (thread_info); + th = XCNEW (windows_thread_info); th->id = id; th->h = h; th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb; @@ -365,18 +409,18 @@ windows_add_thread (ptid_t ptid, HANDLE h, void *tlb) return th; } -/* Clear out any old thread list and reintialize it to a +/* Clear out any old thread list and reinitialize it to a pristine state. */ static void windows_init_thread_list (void) { - thread_info *th = &thread_head; + windows_thread_info *th = &thread_head; DEBUG_EVENTS (("gdb: windows_init_thread_list\n")); init_thread_list (); while (th->next != NULL) { - thread_info *here = th->next; + windows_thread_info *here = th->next; th->next = here->next; xfree (here); } @@ -387,7 +431,7 @@ windows_init_thread_list (void) static void windows_delete_thread (ptid_t ptid, DWORD exit_code) { - thread_info *th; + windows_thread_info *th; DWORD id; gdb_assert (ptid_get_tid (ptid) != 0); @@ -408,43 +452,40 @@ windows_delete_thread (ptid_t ptid, DWORD exit_code) if (th->next != NULL) { - thread_info *here = th->next; + windows_thread_info *here = th->next; th->next = here->next; + xfree (here->name); xfree (here); } } static void -do_windows_fetch_inferior_registers (struct regcache *regcache, int r) +do_windows_fetch_inferior_registers (struct regcache *regcache, + windows_thread_info *th, int r) { - char *context_offset = ((char *) ¤t_thread->context) + mappings[r]; + char *context_offset = ((char *) &th->context) + mappings[r]; struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); long l; - if (!current_thread) - return; /* Windows sometimes uses a non-existent thread id in its - events. */ - - if (current_thread->reload_context) + if (th->reload_context) { -#ifdef __COPY_CONTEXT_SIZE +#ifdef __CYGWIN__ if (have_saved_context) { /* Lie about where the program actually is stopped since cygwin has informed us that we should consider the signal to have occurred at another location which is stored in "saved_context. */ - memcpy (¤t_thread->context, &saved_context, + memcpy (&th->context, &saved_context, __COPY_CONTEXT_SIZE); have_saved_context = 0; } else #endif { - thread_info *th = current_thread; th->context.ContextFlags = CONTEXT_DEBUGGER_DR; - GetThreadContext (th->h, &th->context); + CHECK (GetThreadContext (th->h, &th->context)); /* Copy dr values from that thread. But only if there were not modified since last stop. PR gdb/2388 */ @@ -458,7 +499,7 @@ do_windows_fetch_inferior_registers (struct regcache *regcache, int r) dr[7] = th->context.Dr7; } } - current_thread->reload_context = 0; + th->reload_context = 0; } if (r == I387_FISEG_REGNUM (tdep)) @@ -484,7 +525,7 @@ do_windows_fetch_inferior_registers (struct regcache *regcache, int r) else { for (r = 0; r < gdbarch_num_regs (gdbarch); r++) - do_windows_fetch_inferior_registers (regcache, r); + do_windows_fetch_inferior_registers (regcache, th, r); } } @@ -492,38 +533,42 @@ static void windows_fetch_inferior_registers (struct target_ops *ops, struct regcache *regcache, int r) { - current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE); - /* Check if current_thread exists. Windows sometimes uses a non-existent + DWORD pid = ptid_get_tid (regcache_get_ptid (regcache)); + windows_thread_info *th = thread_rec (pid, TRUE); + + /* Check if TH exists. Windows sometimes uses a non-existent thread id in its events. */ - if (current_thread) - do_windows_fetch_inferior_registers (regcache, r); + if (th != NULL) + do_windows_fetch_inferior_registers (regcache, th, r); } static void -do_windows_store_inferior_registers (const struct regcache *regcache, int r) +do_windows_store_inferior_registers (const struct regcache *regcache, + windows_thread_info *th, int r) { - if (!current_thread) - /* Windows sometimes uses a non-existent thread id in its events. */; - else if (r >= 0) + if (r >= 0) regcache_raw_collect (regcache, r, - ((char *) ¤t_thread->context) + mappings[r]); + ((char *) &th->context) + mappings[r]); else { for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++) - do_windows_store_inferior_registers (regcache, r); + do_windows_store_inferior_registers (regcache, th, r); } } -/* Store a new register value into the current thread context. */ +/* Store a new register value into the context of the thread tied to + REGCACHE. */ static void windows_store_inferior_registers (struct target_ops *ops, struct regcache *regcache, int r) { - current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE); - /* Check if current_thread exists. Windows sometimes uses a non-existent + DWORD pid = ptid_get_tid (regcache_get_ptid (regcache)); + windows_thread_info *th = thread_rec (pid, TRUE); + + /* Check if TH exists. Windows sometimes uses a non-existent thread id in its events. */ - if (current_thread) - do_windows_store_inferior_registers (regcache, r); + if (th != NULL) + do_windows_store_inferior_registers (regcache, th, r); } /* Encapsulate the information required in a call to @@ -540,68 +585,13 @@ struct safe_symbol_file_add_args }; /* Maintain a linked list of "so" information. */ -struct lm_info +struct lm_info_windows : public lm_info_base { - LPVOID load_addr; + LPVOID load_addr = 0; }; static struct so_list solib_start, *solib_end; -/* Call symbol_file_add with stderr redirected. We don't care if there - are errors. */ -static int -safe_symbol_file_add_stub (void *argv) -{ -#define p ((struct safe_symbol_file_add_args *) argv) - const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0) - | (p->mainline ? SYMFILE_MAINLINE : 0)); - p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags); - return !!p->ret; -#undef p -} - -/* Restore gdb's stderr after calling symbol_file_add. */ -static void -safe_symbol_file_add_cleanup (void *p) -{ -#define sp ((struct safe_symbol_file_add_args *)p) - gdb_flush (gdb_stderr); - gdb_flush (gdb_stdout); - ui_file_delete (gdb_stderr); - ui_file_delete (gdb_stdout); - gdb_stderr = sp->err; - gdb_stdout = sp->out; -#undef sp -} - -/* symbol_file_add wrapper that prevents errors from being displayed. */ -static struct objfile * -safe_symbol_file_add (char *name, int from_tty, - struct section_addr_info *addrs, - int mainline, int flags) -{ - struct safe_symbol_file_add_args p; - struct cleanup *cleanup; - - cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p); - - p.err = gdb_stderr; - p.out = gdb_stdout; - gdb_flush (gdb_stderr); - gdb_flush (gdb_stdout); - gdb_stderr = ui_file_new (); - gdb_stdout = ui_file_new (); - p.name = name; - p.from_tty = from_tty; - p.addrs = addrs; - p.mainline = mainline; - p.flags = flags; - catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR); - - do_cleanups (cleanup); - return p.ret; -} - static struct so_list * windows_make_so (const char *name, LPVOID load_addr) { @@ -655,8 +645,9 @@ windows_make_so (const char *name, LPVOID load_addr) } #endif so = XCNEW (struct so_list); - so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info)); - so->lm_info->load_addr = load_addr; + lm_info_windows *li = new lm_info_windows; + so->lm_info = li; + li->load_addr = load_addr; strcpy (so->so_original_name, name); #ifndef __CYGWIN__ strcpy (so->so_name, buf); @@ -679,32 +670,27 @@ windows_make_so (const char *name, LPVOID load_addr) p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1); if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0) { - bfd *abfd; asection *text = NULL; CORE_ADDR text_vma; - abfd = gdb_bfd_open (so->so_name, "pei-i386", -1); + gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386", -1)); - if (!abfd) + if (abfd == NULL) return so; - if (bfd_check_format (abfd, bfd_object)) - text = bfd_get_section_by_name (abfd, ".text"); + if (bfd_check_format (abfd.get (), bfd_object)) + text = bfd_get_section_by_name (abfd.get (), ".text"); if (!text) - { - gdb_bfd_unref (abfd); - return so; - } + return so; /* The symbols in a dll are offset by 0x1000, which is the offset from 0 of the first byte in an image - because of the file header and the section alignment. */ cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000); - cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text); - - gdb_bfd_unref (abfd); + cygwin_load_end = cygwin_load_start + bfd_section_size (abfd.get (), + text); } #endif @@ -787,8 +773,10 @@ handle_load_dll (void *dummy) solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll); solib_end = solib_end->next; + lm_info_windows *li = (lm_info_windows *) solib_end->lm_info; + DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name, - host_address_to_string (solib_end->lm_info->load_addr))); + host_address_to_string (li->load_addr))); return 1; } @@ -796,8 +784,9 @@ handle_load_dll (void *dummy) static void windows_free_so (struct so_list *so) { - if (so->lm_info) - xfree (so->lm_info); + lm_info_windows *li = (lm_info_windows *) so->lm_info; + + delete li; xfree (so); } @@ -816,18 +805,22 @@ handle_unload_dll (void *dummy) struct so_list *so; for (so = &solib_start; so->next != NULL; so = so->next) - if (so->next->lm_info->load_addr == lpBaseOfDll) - { - struct so_list *sodel = so->next; + { + lm_info_windows *li_next = (lm_info_windows *) so->next->lm_info; - so->next = sodel->next; - if (!so->next) - solib_end = so; - DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name)); + if (li_next->load_addr == lpBaseOfDll) + { + struct so_list *sodel = so->next; - windows_free_so (sodel); - return 1; - } + so->next = sodel->next; + if (!so->next) + solib_end = so; + DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name)); + + windows_free_so (sodel); + return 1; + } + } /* We did not find any DLL that was previously loaded at this address, so register a complaint. We do not report an error, because we have @@ -850,26 +843,23 @@ windows_clear_solib (void) solib_end = &solib_start; } -/* Load DLL symbol info. */ static void -dll_symbol_command (char *args, int from_tty) +signal_event_command (char *args, int from_tty) { - int n; - dont_repeat (); + uintptr_t event_id = 0; + char *endargs = NULL; if (args == NULL) - error (_("dll-symbols requires a file name")); + error (_("signal-event requires an argument (integer event id)")); - n = strlen (args); - if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0) - { - char *newargs = (char *) alloca (n + 4 + 1); - strcpy (newargs, args); - strcat (newargs, ".dll"); - args = newargs; - } + event_id = strtoumax (args, &endargs, 10); - safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED); + if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) || + ((HANDLE) event_id == INVALID_HANDLE_VALUE)) + error (_("Failed to convert `%s' to event id"), args); + + SetEvent ((HANDLE) event_id); + CloseHandle ((HANDLE) event_id); } /* Handle DEBUG_STRING output from child process. @@ -886,15 +876,20 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) &s, 1024, 0) || !s || !*s) /* nothing to do */; - else if (strncmp (s, _CYGWIN_SIGNAL_STRING, - sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0) + else if (!startswith (s, _CYGWIN_SIGNAL_STRING)) { #ifdef __CYGWIN__ - if (strncmp (s, "cYg", 3) != 0) + if (!startswith (s, "cYg")) #endif - warning (("%s"), s); + { + char *p = strchr (s, '\0'); + + if (p > s && *--p == '\n') + *p = '\0'; + warning (("%s"), s); + } } -#ifdef __COPY_CONTEXT_SIZE +#ifdef __CYGWIN__ else { /* Got a cygwin signal marker. A cygwin signal is followed by @@ -906,7 +901,7 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) to treat this like a real signal. */ char *p; int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0); - int gotasig = gdb_signal_from_host (sig); + gdb_signal gotasig = gdb_signal_from_host (sig); ourstatus->value.sig = gotasig; if (gotasig) @@ -924,7 +919,6 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) __COPY_CONTEXT_SIZE, &n) && n == __COPY_CONTEXT_SIZE) have_saved_context = 1; - current_event.dwThreadId = retval; } } #endif @@ -1054,16 +1048,17 @@ display_selectors (char * args, int from_tty) host_address_to_string (\ current_event.u.Exception.ExceptionRecord.ExceptionAddress)) -static int +static handle_exception_result handle_exception (struct target_waitstatus *ourstatus) { - thread_info *th; - DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode; + EXCEPTION_RECORD *rec = ¤t_event.u.Exception.ExceptionRecord; + DWORD code = rec->ExceptionCode; + handle_exception_result result = HANDLE_EXCEPTION_HANDLED; ourstatus->kind = TARGET_WAITKIND_STOPPED; /* Record the context of the current thread. */ - th = thread_rec (current_event.dwThreadId, -1); + thread_rec (current_event.dwThreadId, -1); switch (code) { @@ -1081,15 +1076,13 @@ handle_exception (struct target_waitstatus *ourstatus) cygwin-specific-signal. So, ignore SEGVs if they show up within the text segment of the DLL itself. */ const char *fn; - CORE_ADDR addr = (CORE_ADDR) (uintptr_t) - current_event.u.Exception.ExceptionRecord.ExceptionAddress; + CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress; if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end)) || (find_pc_partial_function (addr, &fn, NULL, NULL) - && strncmp (fn, "KERNEL32!IsBad", - strlen ("KERNEL32!IsBad")) == 0)) - return 0; + && startswith (fn, "KERNEL32!IsBad"))) + return HANDLE_EXCEPTION_UNHANDLED; } #endif break; @@ -1165,10 +1158,48 @@ handle_exception (struct target_waitstatus *ourstatus) DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION"); ourstatus->value.sig = GDB_SIGNAL_ILL; break; + case MS_VC_EXCEPTION: + if (rec->NumberParameters >= 3 + && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000) + { + DWORD named_thread_id; + windows_thread_info *named_thread; + CORE_ADDR thread_name_target; + + DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION"); + + thread_name_target = rec->ExceptionInformation[1]; + named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]); + + if (named_thread_id == (DWORD) -1) + named_thread_id = current_event.dwThreadId; + + named_thread = thread_rec (named_thread_id, 0); + if (named_thread != NULL) + { + int thread_name_len; + char *thread_name; + + thread_name_len = target_read_string (thread_name_target, + &thread_name, 1025, NULL); + if (thread_name_len > 0) + { + thread_name[thread_name_len - 1] = '\0'; + xfree (named_thread->name); + named_thread->name = thread_name; + } + else + xfree (thread_name); + } + ourstatus->value.sig = GDB_SIGNAL_TRAP; + result = HANDLE_EXCEPTION_IGNORED; + break; + } + /* treat improperly formed exception as unknown, fallthrough */ default: /* Treat unhandled first chance exceptions specially. */ if (current_event.u.Exception.dwFirstChance) - return -1; + return HANDLE_EXCEPTION_UNHANDLED; printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n", (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode, host_address_to_string ( @@ -1178,16 +1209,18 @@ handle_exception (struct target_waitstatus *ourstatus) } exception_count++; last_sig = ourstatus->value.sig; - return 1; + return result; } -/* Resume all artificially suspended threads if we are continuing - execution. */ +/* Resume thread specified by ID, or all artificially suspended + threads, if we are continuing execution. KILLED non-zero means we + have killed the inferior, so we should ignore weird errors due to + threads shutting down. */ static BOOL -windows_continue (DWORD continue_status, int id) +windows_continue (DWORD continue_status, int id, int killed) { int i; - thread_info *th; + windows_thread_info *th; BOOL res; DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n", @@ -1212,7 +1245,16 @@ windows_continue (DWORD continue_status, int id) } if (th->context.ContextFlags) { - CHECK (SetThreadContext (th->h, &th->context)); + DWORD ec = 0; + + if (GetExitCodeThread (th->h, &ec) + && ec == STILL_ACTIVE) + { + BOOL status = SetThreadContext (th->h, &th->context); + + if (!killed) + CHECK (status); + } th->context.ContextFlags = 0; } if (th->suspended > 0) @@ -1224,6 +1266,11 @@ windows_continue (DWORD continue_status, int id) current_event.dwThreadId, continue_status); + if (!res) + error (_("Failed to resume program execution" + " (ContinueDebugEvent failed, error %u)"), + (unsigned int) GetLastError ()); + debug_registers_changed = 0; return res; } @@ -1256,7 +1303,7 @@ static void windows_resume (struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal sig) { - thread_info *th; + windows_thread_info *th; DWORD continue_status = DBG_CONTINUE; /* A specific PTID means `step only this thread id'. */ @@ -1297,7 +1344,7 @@ windows_resume (struct target_ops *ops, } } #endif - DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n", + DEBUG_EXCEPT(("Can only continue with received signal %d.\n", last_sig)); } @@ -1340,9 +1387,9 @@ windows_resume (struct target_ops *ops, Otherwise complain. */ if (resume_all) - windows_continue (continue_status, -1); + windows_continue (continue_status, -1, 0); else - windows_continue (continue_status, ptid_get_tid (ptid)); + windows_continue (continue_status, ptid_get_tid (ptid), 0); } /* Ctrl-C handler used when the inferior is not run in the same console. The @@ -1371,17 +1418,17 @@ ctrl_c_handler (DWORD event_type) return TRUE; } -/* Get the next event from the child. Return 1 if the event requires - handling by WFI (or whatever). */ +/* Get the next event from the child. Returns a non-zero thread id if the event + requires handling by WFI (or whatever). */ static int get_windows_debug_event (struct target_ops *ops, int pid, struct target_waitstatus *ourstatus) { BOOL debug_event; DWORD continue_status, event_code; - thread_info *th; - static thread_info dummy_thread_info; - int retval = 0; + windows_thread_info *th; + static windows_thread_info dummy_thread_info; + DWORD thread_id = 0; last_sig = GDB_SIGNAL_0; @@ -1412,14 +1459,14 @@ get_windows_debug_event (struct target_ops *ops, /* Kludge around a Windows bug where first event is a create thread event. Caused when attached process does not have a main thread. */ - retval = fake_create_process (); - if (retval) + thread_id = fake_create_process (); + if (thread_id) saw_create++; } break; } /* Record the existence of this thread. */ - retval = current_event.dwThreadId; + thread_id = current_event.dwThreadId; th = windows_add_thread (ptid_build (current_event.dwProcessId, 0, current_event.dwThreadId), current_event.u.CreateThread.hThread, @@ -1462,7 +1509,7 @@ get_windows_debug_event (struct target_ops *ops, current_event.dwThreadId), current_event.u.CreateProcessInfo.hThread, current_event.u.CreateProcessInfo.lpThreadLocalBase); - retval = current_event.dwThreadId; + thread_id = current_event.dwThreadId; break; case EXIT_PROCESS_DEBUG_EVENT: @@ -1473,7 +1520,7 @@ get_windows_debug_event (struct target_ops *ops, if (!windows_initialization_done) { target_terminal_ours (); - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); error (_("During startup program exited with code 0x%x."), (unsigned int) current_event.u.ExitProcess.dwExitCode); } @@ -1481,7 +1528,7 @@ get_windows_debug_event (struct target_ops *ops, { ourstatus->kind = TARGET_WAITKIND_EXITED; ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode; - retval = main_thread_id; + thread_id = main_thread_id; } break; @@ -1496,7 +1543,7 @@ get_windows_debug_event (struct target_ops *ops, catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL); ourstatus->kind = TARGET_WAITKIND_LOADED; ourstatus->value.integer = 0; - retval = main_thread_id; + thread_id = main_thread_id; break; case UNLOAD_DLL_DEBUG_EVENT: @@ -1509,7 +1556,7 @@ get_windows_debug_event (struct target_ops *ops, catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL); ourstatus->kind = TARGET_WAITKIND_LOADED; ourstatus->value.integer = 0; - retval = main_thread_id; + thread_id = main_thread_id; break; case EXCEPTION_DEBUG_EVENT: @@ -1521,15 +1568,15 @@ get_windows_debug_event (struct target_ops *ops, break; switch (handle_exception (ourstatus)) { - case 0: + case HANDLE_EXCEPTION_UNHANDLED: + default: continue_status = DBG_EXCEPTION_NOT_HANDLED; break; - case 1: - retval = current_event.dwThreadId; + case HANDLE_EXCEPTION_HANDLED: + thread_id = current_event.dwThreadId; break; - case -1: - last_sig = 1; - continue_status = -1; + case HANDLE_EXCEPTION_IGNORED: + continue_status = DBG_CONTINUE; break; } break; @@ -1541,7 +1588,7 @@ get_windows_debug_event (struct target_ops *ops, "OUTPUT_DEBUG_STRING_EVENT")); if (saw_create != 1) break; - retval = handle_output_debug_string (ourstatus); + thread_id = handle_output_debug_string (ourstatus); break; default: @@ -1555,22 +1602,21 @@ get_windows_debug_event (struct target_ops *ops, break; } - if (!retval || saw_create != 1) + if (!thread_id || saw_create != 1) { - if (continue_status == -1) - windows_resume (ops, minus_one_ptid, 0, 1); - else - CHECK (windows_continue (continue_status, -1)); + CHECK (windows_continue (continue_status, -1, 0)); } else { inferior_ptid = ptid_build (current_event.dwProcessId, 0, - retval); - current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE); + thread_id); + current_thread = th; + if (!current_thread) + current_thread = thread_rec (thread_id, TRUE); } out: - return retval; + return thread_id; } /* Wait for interesting events to occur in the target process. */ @@ -1691,7 +1737,6 @@ windows_add_all_dlls (void) static void do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) { - extern int stop_after_trap; int i; struct inferior *inf; struct thread_info *tp; @@ -1709,10 +1754,11 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) #endif current_event.dwProcessId = pid; memset (¤t_event, 0, sizeof (current_event)); - push_target (ops); + if (!target_is_pushed (ops)) + push_target (ops); disable_breakpoints_in_shlibs (); windows_clear_solib (); - clear_proceed_status (); + clear_proceed_status (0); init_wait_for_inferior (); inf = current_inferior (); @@ -1725,20 +1771,24 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) current thread until we report an event out of windows_wait. */ inferior_ptid = pid_to_ptid (pid); - terminal_init_inferior_with_pgrp (pid); + target_terminal_init (); target_terminal_inferior (); windows_initialization_done = 0; - inf->control.stop_soon = STOP_QUIETLY; + while (1) { - stop_after_trap = 1; - wait_for_inferior (); - tp = inferior_thread (); - if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP) - resume (0, tp->suspend.stop_signal); - else + struct target_waitstatus status; + + windows_wait (ops, minus_one_ptid, &status, 0); + + /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread + events. */ + if (status.kind != TARGET_WAITKIND_LOADED + && status.kind != TARGET_WAITKIND_SPURIOUS) break; + + windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0); } /* Now that the inferior has been started and all DLLs have been mapped, @@ -1759,8 +1809,6 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) windows_add_all_dlls (); windows_initialization_done = 1; - inf->control.stop_soon = NO_STOP_QUIETLY; - stop_after_trap = 0; return; } @@ -1815,7 +1863,7 @@ out: /* Attach to process PID, then initialize for debugging it. */ static void -windows_attach (struct target_ops *ops, char *args, int from_tty) +windows_attach (struct target_ops *ops, const char *args, int from_tty) { BOOL ok; DWORD pid; @@ -1872,7 +1920,7 @@ windows_detach (struct target_ops *ops, const char *args, int from_tty) { int detached = 1; - ptid_t ptid = {-1}; + ptid_t ptid = minus_one_ptid; windows_resume (ops, ptid, 0, GDB_SIGNAL_0); if (!DebugActiveProcessStop (current_event.dwProcessId)) @@ -1885,7 +1933,7 @@ windows_detach (struct target_ops *ops, const char *args, int from_tty) if (detached && from_tty) { - char *exec_file = get_exec_file (0); + const char *exec_file = get_exec_file (0); if (exec_file == 0) exec_file = ""; printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file, @@ -1893,11 +1941,11 @@ windows_detach (struct target_ops *ops, const char *args, int from_tty) gdb_flush (gdb_stdout); } - i386_cleanup_dregs (); + x86_cleanup_dregs (); inferior_ptid = null_ptid; detach_inferior (current_event.dwProcessId); - unpush_target (ops); + inf_child_maybe_unpush_target (ops); } /* Try to determine the executable filename. @@ -1930,7 +1978,7 @@ windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len) /* Cygwin prefers that the path be in /x/y/z format, so extract the filename into a temporary buffer first, and then convert it to POSIX format into the destination buffer. */ - cygwin_buf_t *pathbuf = alloca (exe_name_max_len * sizeof (cygwin_buf_t)); + cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t)); len = GetModuleFileNameEx (current_process_handle, dh_buf, pathbuf, exe_name_max_len); @@ -2071,14 +2119,310 @@ clear_win32_environment (char **env) } #endif +#ifndef __CYGWIN__ + +/* Redirection of inferior I/O streams for native MS-Windows programs. + Unlike on Unix, where this is handled by invoking the inferior via + the shell, on MS-Windows we need to emulate the cmd.exe shell. + + The official documentation of the cmd.exe redirection features is here: + + http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx + + (That page talks about Windows XP, but there's no newer + documentation, so we assume later versions of cmd.exe didn't change + anything.) + + Caveat: the documentation on that page seems to include a few lies. + For example, it describes strange constructs 1<&2 and 2<&1, which + seem to work only when 1>&2 resp. 2>&1 would make sense, and so I + think the cmd.exe parser of the redirection symbols simply doesn't + care about the < vs > distinction in these cases. Therefore, the + supported features are explicitly documented below. + + The emulation below aims at supporting all the valid use cases + supported by cmd.exe, which include: + + < FILE redirect standard input from FILE + 0< FILE redirect standard input from FILE + <&N redirect standard input from file descriptor N + 0<&N redirect standard input from file descriptor N + > FILE redirect standard output to FILE + >> FILE append standard output to FILE + 1>> FILE append standard output to FILE + >&N redirect standard output to file descriptor N + 1>&N redirect standard output to file descriptor N + >>&N append standard output to file descriptor N + 1>>&N append standard output to file descriptor N + 2> FILE redirect standard error to FILE + 2>> FILE append standard error to FILE + 2>&N redirect standard error to file descriptor N + 2>>&N append standard error to file descriptor N + + Note that using N > 2 in the above construct is supported, but + requires that the corresponding file descriptor be open by some + means elsewhere or outside GDB. Also note that using ">&0" or + "<&2" will generally fail, because the file descriptor redirected + from is normally open in an incompatible mode (e.g., FD 0 is open + for reading only). IOW, use of such tricks is not recommended; + you are on your own. + + We do NOT support redirection of file descriptors above 2, as in + "3>SOME-FILE", because MinGW compiled programs don't (supporting + that needs special handling in the startup code that MinGW + doesn't have). Pipes are also not supported. + + As for invalid use cases, where the redirection contains some + error, the emulation below will detect that and produce some + error and/or failure. But the behavior in those cases is not + bug-for-bug compatible with what cmd.exe does in those cases. + That's because what cmd.exe does then is not well defined, and + seems to be a side effect of the cmd.exe parsing of the command + line more than anything else. For example, try redirecting to an + invalid file name, as in "> foo:bar". + + There are also minor syntactic deviations from what cmd.exe does + in some corner cases. For example, it doesn't support the likes + of "> &foo" to mean redirect to file named literally "&foo"; we + do support that here, because that, too, sounds like some issue + with the cmd.exe parser. Another nicety is that we support + redirection targets that use file names with forward slashes, + something cmd.exe doesn't -- this comes in handy since GDB + file-name completion can be used when typing the command line for + the inferior. */ + +/* Support routines for redirecting standard handles of the inferior. */ + +/* Parse a single redirection spec, open/duplicate the specified + file/fd, and assign the appropriate value to one of the 3 standard + file descriptors. */ +static int +redir_open (const char *redir_string, int *inp, int *out, int *err) +{ + int *fd, ref_fd = -2; + int mode; + const char *fname = redir_string + 1; + int rc = *redir_string; + + switch (rc) + { + case '0': + fname++; + /* FALLTHROUGH */ + case '<': + fd = inp; + mode = O_RDONLY; + break; + case '1': case '2': + fname++; + /* FALLTHROUGH */ + case '>': + fd = (rc == '2') ? err : out; + mode = O_WRONLY | O_CREAT; + if (*fname == '>') + { + fname++; + mode |= O_APPEND; + } + else + mode |= O_TRUNC; + break; + default: + return -1; + } + + if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9') + { + /* A reference to a file descriptor. */ + char *fdtail; + ref_fd = (int) strtol (fname + 1, &fdtail, 10); + if (fdtail > fname + 1 && *fdtail == '\0') + { + /* Don't allow redirection when open modes are incompatible. */ + if ((ref_fd == 0 && (fd == out || fd == err)) + || ((ref_fd == 1 || ref_fd == 2) && fd == inp)) + { + errno = EPERM; + return -1; + } + if (ref_fd == 0) + ref_fd = *inp; + else if (ref_fd == 1) + ref_fd = *out; + else if (ref_fd == 2) + ref_fd = *err; + } + else + { + errno = EBADF; + return -1; + } + } + else + fname++; /* skip the separator space */ + /* If the descriptor is already open, close it. This allows + multiple specs of redirections for the same stream, which is + somewhat nonsensical, but still valid and supported by cmd.exe. + (But cmd.exe only opens a single file in this case, the one + specified by the last redirection spec on the command line.) */ + if (*fd >= 0) + _close (*fd); + if (ref_fd == -2) + { + *fd = _open (fname, mode, _S_IREAD | _S_IWRITE); + if (*fd < 0) + return -1; + } + else if (ref_fd == -1) + *fd = -1; /* reset to default destination */ + else + { + *fd = _dup (ref_fd); + if (*fd < 0) + return -1; + } + /* _open just sets a flag for O_APPEND, which won't be passed to the + inferior, so we need to actually move the file pointer. */ + if ((mode & O_APPEND) != 0) + _lseek (*fd, 0L, SEEK_END); + return 0; +} + +/* Canonicalize a single redirection spec and set up the corresponding + file descriptor as specified. */ +static int +redir_set_redirection (const char *s, int *inp, int *out, int *err) +{ + char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */ + char *d = buf; + const char *start = s; + int quote = 0; + + *d++ = *s++; /* copy the 1st character, < or > or a digit */ + if ((*start == '>' || *start == '1' || *start == '2') + && *s == '>') + { + *d++ = *s++; + if (*s == '>' && *start != '>') + *d++ = *s++; + } + else if (*start == '0' && *s == '<') + *d++ = *s++; + /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */ + if (*s != '&') + { + while (isspace (*s)) /* skip whitespace before file name */ + s++; + *d++ = ' '; /* separate file name with a single space */ + } + + /* Copy the file name. */ + while (*s) + { + /* Remove quoting characters from the file name in buf[]. */ + if (*s == '"') /* could support '..' quoting here */ + { + if (!quote) + quote = *s++; + else if (*s == quote) + { + quote = 0; + s++; + } + else + *d++ = *s++; + } + else if (*s == '\\') + { + if (s[1] == '"') /* could support '..' here */ + s++; + *d++ = *s++; + } + else if (isspace (*s) && !quote) + break; + else + *d++ = *s++; + if (d - buf >= sizeof (buf) - 1) + { + errno = ENAMETOOLONG; + return 0; + } + } + *d = '\0'; + + /* Windows doesn't allow redirection characters in file names, so we + can bail out early if they use them, or if there's no target file + name after the redirection symbol. */ + if (d[-1] == '>' || d[-1] == '<') + { + errno = ENOENT; + return 0; + } + if (redir_open (buf, inp, out, err) == 0) + return s - start; + return 0; +} + +/* Parse the command line for redirection specs and prepare the file + descriptors for the 3 standard streams accordingly. */ +static bool +redirect_inferior_handles (const char *cmd_orig, char *cmd, + int *inp, int *out, int *err) +{ + const char *s = cmd_orig; + char *d = cmd; + int quote = 0; + bool retval = false; + + while (isspace (*s)) + *d++ = *s++; + + while (*s) + { + if (*s == '"') /* could also support '..' quoting here */ + { + if (!quote) + quote = *s; + else if (*s == quote) + quote = 0; + } + else if (*s == '\\') + { + if (s[1] == '"') /* escaped quote char */ + s++; + } + else if (!quote) + { + /* Process a single redirection candidate. */ + if (*s == '<' || *s == '>' + || ((*s == '1' || *s == '2') && s[1] == '>') + || (*s == '0' && s[1] == '<')) + { + int skip = redir_set_redirection (s, inp, out, err); + + if (skip <= 0) + return false; + retval = true; + s += skip; + } + } + if (*s) + *d++ = *s++; + } + *d = '\0'; + return retval; +} +#endif /* !__CYGWIN__ */ + /* Start an inferior windows child process and sets inferior_ptid to its pid. EXEC_FILE is the file to run. ALLARGS is a string containing the arguments to the program. ENV is the environment vector to pass. Errors reported with error(). */ static void -windows_create_inferior (struct target_ops *ops, char *exec_file, - char *allargs, char **in_env, int from_tty) +windows_create_inferior (struct target_ops *ops, const char *exec_file, + const std::string &origallargs, char **in_env, + int from_tty) { STARTUPINFO si; #ifdef __CYGWIN__ @@ -2093,20 +2437,26 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, size_t len; int tty; int ostdin, ostdout, ostderr; -#else +#else /* !__CYGWIN__ */ char real_path[__PMAX]; char shell[__PMAX]; /* Path to shell */ - char *toexec; - char *args; - size_t args_len; - HANDLE tty; + const char *toexec; + char *args, *allargs_copy; + size_t args_len, allargs_len; + int fd_inp = -1, fd_out = -1, fd_err = -1; + HANDLE tty = INVALID_HANDLE_VALUE; + HANDLE inf_stdin = INVALID_HANDLE_VALUE; + HANDLE inf_stdout = INVALID_HANDLE_VALUE; + HANDLE inf_stderr = INVALID_HANDLE_VALUE; + bool redirected = false; char *w32env; char *temp; size_t envlen; int i; size_t envsize; char **env; -#endif +#endif /* !__CYGWIN__ */ + const char *allargs = origallargs.c_str (); PROCESS_INFORMATION pi; BOOL ret; DWORD flags = 0; @@ -2138,7 +2488,7 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, error (_("Error starting executable: %d"), errno); cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t)); mbstowcs (cygallargs, allargs, len); -#else +#else /* !__USEWIDE */ cygallargs = allargs; #endif } @@ -2154,12 +2504,12 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, + mbstowcs (NULL, allargs, 0) + 2; cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t)); swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs); -#else +#else /* !__USEWIDE */ len = (sizeof (" -c 'exec '") + strlen (exec_file) + strlen (allargs) + 2); cygallargs = (char *) alloca (len); xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs); -#endif +#endif /* __USEWIDE */ toexec = shell; flags |= DEBUG_PROCESS; } @@ -2170,12 +2520,12 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, wcscpy (args, toexec); wcscat (args, L" "); wcscat (args, cygallargs); -#else +#else /* !__USEWIDE */ args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2); strcpy (args, toexec); strcat (args, " "); strcat (args, cygallargs); -#endif +#endif /* !__USEWIDE */ #ifdef CW_CVT_ENV_TO_WINENV /* First try to create a direct Win32 copy of the POSIX environment. */ @@ -2184,7 +2534,7 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, flags |= CREATE_UNICODE_ENVIRONMENT; else /* If that fails, fall back to old method tweaking GDB's environment. */ -#endif +#endif /* CW_CVT_ENV_TO_WINENV */ { /* Reset all Win32 environment variables to avoid leftover on next run. */ clear_win32_environment (environ); @@ -2249,21 +2599,26 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, close (ostdout); close (ostderr); } -#else - toexec = exec_file; - /* Build the command line, a space-separated list of tokens where - the first token is the name of the module to be executed. - To avoid ambiguities introduced by spaces in the module name, - we quote it. */ - args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2; - args = alloca (args_len); - xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs); - - flags |= DEBUG_ONLY_THIS_PROCESS; - - if (!inferior_io_terminal) - tty = INVALID_HANDLE_VALUE; - else +#else /* !__CYGWIN__ */ + allargs_len = strlen (allargs); + allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs); + if (strpbrk (allargs_copy, "<>") != NULL) + { + int e = errno; + errno = 0; + redirected = + redirect_inferior_handles (allargs, allargs_copy, + &fd_inp, &fd_out, &fd_err); + if (errno) + warning (_("Error in redirection: %s."), strerror (errno)); + else + errno = e; + allargs_len = strlen (allargs_copy); + } + /* If not all the standard streams are redirected by the command + line, use inferior_io_terminal for those which aren't. */ + if (inferior_io_terminal + && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0)) { SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(sa); @@ -2274,15 +2629,41 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, if (tty == INVALID_HANDLE_VALUE) warning (_("Warning: Failed to open TTY %s, error %#x."), inferior_io_terminal, (unsigned) GetLastError ()); + } + if (redirected || tty != INVALID_HANDLE_VALUE) + { + if (fd_inp >= 0) + si.hStdInput = (HANDLE) _get_osfhandle (fd_inp); + else if (tty != INVALID_HANDLE_VALUE) + si.hStdInput = tty; else - { - si.hStdInput = tty; - si.hStdOutput = tty; - si.hStdError = tty; - si.dwFlags |= STARTF_USESTDHANDLES; - } + si.hStdInput = GetStdHandle (STD_INPUT_HANDLE); + if (fd_out >= 0) + si.hStdOutput = (HANDLE) _get_osfhandle (fd_out); + else if (tty != INVALID_HANDLE_VALUE) + si.hStdOutput = tty; + else + si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE); + if (fd_err >= 0) + si.hStdError = (HANDLE) _get_osfhandle (fd_err); + else if (tty != INVALID_HANDLE_VALUE) + si.hStdError = tty; + else + si.hStdError = GetStdHandle (STD_ERROR_HANDLE); + si.dwFlags |= STARTF_USESTDHANDLES; } + toexec = exec_file; + /* Build the command line, a space-separated list of tokens where + the first token is the name of the module to be executed. + To avoid ambiguities introduced by spaces in the module name, + we quote it. */ + args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2; + args = (char *) alloca (args_len); + xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy); + + flags |= DEBUG_ONLY_THIS_PROCESS; + /* CreateProcess takes the environment list as a null terminated set of strings (i.e. two nulls terminate the list). */ @@ -2296,7 +2677,7 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, /* Windows programs expect the environment block to be sorted. */ qsort (env, i, sizeof (char *), envvar_cmp); - w32env = alloca (envlen + 1); + w32env = (char *) alloca (envlen + 1); /* Copy env strings into new buffer. */ for (temp = w32env, i = 0; env[i] && *env[i]; i++) @@ -2321,7 +2702,13 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, &pi); if (tty != INVALID_HANDLE_VALUE) CloseHandle (tty); -#endif + if (fd_inp >= 0) + _close (fd_inp); + if (fd_out >= 0) + _close (fd_out); + if (fd_err >= 0) + _close (fd_err); +#endif /* !__CYGWIN__ */ if (!ret) error (_("Error creating process %s, (error %u)."), @@ -2337,28 +2724,27 @@ windows_create_inferior (struct target_ops *ops, char *exec_file, do_initial_windows_stuff (ops, pi.dwProcessId, 0); - /* windows_continue (DBG_CONTINUE, -1); */ + /* windows_continue (DBG_CONTINUE, -1, 0); */ } static void windows_mourn_inferior (struct target_ops *ops) { - (void) windows_continue (DBG_CONTINUE, -1); - i386_cleanup_dregs(); + (void) windows_continue (DBG_CONTINUE, -1, 0); + x86_cleanup_dregs(); if (open_process_used) { CHECK (CloseHandle (current_process_handle)); open_process_used = 0; } - unpush_target (ops); - generic_mourn_inferior (); + inf_child_mourn_inferior (ops); } /* Send a SIGINT to the process group. This acts just like the user typed a ^C on the controlling terminal. */ static void -windows_stop (struct target_ops *self, ptid_t ptid) +windows_interrupt (struct target_ops *self, ptid_t ptid) { DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n")); CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId)); @@ -2412,7 +2798,7 @@ windows_kill_inferior (struct target_ops *ops) for (;;) { - if (!windows_continue (DBG_CONTINUE, -1)) + if (!windows_continue (DBG_CONTINUE, -1, 1)) break; if (!WaitForDebugEvent (¤t_event, INFINITE)) break; @@ -2420,7 +2806,7 @@ windows_kill_inferior (struct target_ops *ops) break; } - target_mourn_inferior (); /* Or just windows_mourn_inferior? */ + target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */ } static void @@ -2431,7 +2817,7 @@ windows_close (struct target_ops *self) } /* Convert pid to printable format. */ -static char * +static const char * windows_pid_to_str (struct target_ops *ops, ptid_t ptid) { static char buf[80]; @@ -2464,12 +2850,16 @@ windows_xfer_shared_libraries (struct target_ops *ops, obstack_init (&obstack); obstack_grow_str (&obstack, "\n"); for (so = solib_start.next; so; so = so->next) - windows_xfer_shared_library (so->so_name, (CORE_ADDR) - (uintptr_t) so->lm_info->load_addr, - target_gdbarch (), &obstack); + { + lm_info_windows *li = (lm_info_windows *) so->lm_info; + + windows_xfer_shared_library (so->so_name, (CORE_ADDR) + (uintptr_t) li->load_addr, + target_gdbarch (), &obstack); + } obstack_grow_str0 (&obstack, "\n"); - buf = obstack_finish (&obstack); + buf = (const char *) obstack_finish (&obstack); len_avail = strlen (buf); if (offset >= len_avail) len= 0; @@ -2501,11 +2891,9 @@ windows_xfer_partial (struct target_ops *ops, enum target_object object, writebuf, offset, len, xfered_len); default: - if (ops->beneath != NULL) - return ops->beneath->to_xfer_partial (ops->beneath, object, annex, - readbuf, writebuf, offset, len, - xfered_len); - return TARGET_XFER_E_IO; + return ops->beneath->to_xfer_partial (ops->beneath, object, annex, + readbuf, writebuf, offset, len, + xfered_len); } } @@ -2516,7 +2904,7 @@ static int windows_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr) { - thread_info *th; + windows_thread_info *th; th = thread_rec (ptid_get_tid (ptid), 0); if (th == NULL) @@ -2534,14 +2922,19 @@ windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp); } +/* Implementation of the to_thread_name method. */ + +static const char * +windows_thread_name (struct target_ops *self, struct thread_info *thr) +{ + return thread_rec (ptid_get_tid (thr->ptid), 0)->name; +} + static struct target_ops * windows_target (void) { struct target_ops *t = inf_child_target (); - t->to_shortname = "child"; - t->to_longname = "Win32 child process"; - t->to_doc = "Win32 child process (started by the \"run\" command)."; t->to_close = windows_close; t->to_attach = windows_attach; t->to_attach_no_wait = 1; @@ -2557,41 +2950,35 @@ windows_target (void) t->to_mourn_inferior = windows_mourn_inferior; t->to_thread_alive = windows_thread_alive; t->to_pid_to_str = windows_pid_to_str; - t->to_stop = windows_stop; + t->to_interrupt = windows_interrupt; t->to_pid_to_exec_file = windows_pid_to_exec_file; t->to_get_ada_task_ptid = windows_get_ada_task_ptid; t->to_get_tib_address = windows_get_tib_address; + t->to_thread_name = windows_thread_name; return t; } -static void -set_windows_aliases (char *argv0) -{ - add_info_alias ("dll", "sharedlibrary", 1); -} - /* -Wmissing-prototypes */ extern initialize_file_ftype _initialize_windows_nat; void _initialize_windows_nat (void) { - struct cmd_list_element *c; struct target_ops *t; t = windows_target (); - i386_use_watchpoints (t); + x86_use_watchpoints (t); - i386_dr_low.set_control = cygwin_set_dr7; - i386_dr_low.set_addr = cygwin_set_dr; - i386_dr_low.get_addr = cygwin_get_dr; - i386_dr_low.get_status = cygwin_get_dr6; - i386_dr_low.get_control = cygwin_get_dr7; + x86_dr_low.set_control = cygwin_set_dr7; + x86_dr_low.set_addr = cygwin_set_dr; + x86_dr_low.get_addr = cygwin_get_dr; + x86_dr_low.get_status = cygwin_get_dr6; + x86_dr_low.get_control = cygwin_get_dr7; - /* i386_dr_low.debug_register_length field is set by - calling i386_set_debug_register_length function + /* x86_dr_low.debug_register_length field is set by + calling x86_set_debug_register_length function in processor windows specific native file. */ add_target (t); @@ -2600,20 +2987,12 @@ _initialize_windows_nat (void) cygwin_internal (CW_SET_DOS_FILE_WARNING, 0); #endif - c = add_com ("dll-symbols", class_files, dll_symbol_command, - _("Load dll library symbols from FILE.")); - set_cmd_completer (c, filename_completer); - deprecate_cmd (c, "sharedlibrary"); - - c = add_com ("add-shared-symbol-files", class_files, dll_symbol_command, - _("Load dll library symbols from FILE.")); - set_cmd_completer (c, filename_completer); - deprecate_cmd (c, "sharedlibrary"); - - c = add_com ("assf", class_files, dll_symbol_command, - _("Load dll library symbols from FILE.")); - set_cmd_completer (c, filename_completer); - deprecate_cmd (c, "sharedlibrary"); + add_com ("signal-event", class_run, signal_event_command, _("\ +Signal a crashed process with event ID, to allow its debugging.\n\ +This command is needed in support of setting up GDB as JIT debugger on \ +MS-Windows. The command should be invoked from the GDB command line using \ +the '-ex' command-line option. The ID of the event that blocks the \ +crashed process will be supplied by the Windows JIT debugging mechanism.")); #ifdef __CYGWIN__ add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\ @@ -2680,7 +3059,6 @@ Show whether to display kernel exceptions in child process."), NULL, add_cmd ("selector", class_info, display_selectors, _("Display selectors infos."), &info_w32_cmdlist); - deprecated_init_ui_hook = set_windows_aliases; } /* Hardware watchpoint support, adapted from go32-nat.c code. */ @@ -2767,7 +3145,7 @@ _initialize_check_for_gdb_ini (void) { char *p; char *oldini = (char *) alloca (strlen (homedir) + - sizeof ("/gdb.ini")); + sizeof ("gdb.ini") + 1); strcpy (oldini, homedir); p = strchr (oldini, '\0'); if (p > oldini && !IS_DIR_SEPARATOR (p[-1])) @@ -2776,9 +3154,9 @@ _initialize_check_for_gdb_ini (void) if (access (oldini, 0) == 0) { int len = strlen (oldini); - char *newini = alloca (len + 1); + char *newini = (char *) alloca (len + 2); - xsnprintf (newini, len + 1, "%.*s.gdbinit", + xsnprintf (newini, len + 2, "%.*s.gdbinit", (int) (len - (sizeof ("gdb.ini") - 1)), oldini); warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini); } @@ -2860,19 +3238,18 @@ _initialize_loadable (void) { HMODULE hm = NULL; +#define GPA(m, func) \ + func = (func ## _ftype *) GetProcAddress (m, #func) + hm = LoadLibrary ("kernel32.dll"); if (hm) { - DebugActiveProcessStop = (void *) - GetProcAddress (hm, "DebugActiveProcessStop"); - DebugBreakProcess = (void *) - GetProcAddress (hm, "DebugBreakProcess"); - DebugSetProcessKillOnExit = (void *) - GetProcAddress (hm, "DebugSetProcessKillOnExit"); - GetConsoleFontSize = (void *) - GetProcAddress (hm, "GetConsoleFontSize"); - GetCurrentConsoleFont = (void *) - GetProcAddress (hm, "GetCurrentConsoleFont"); + GPA (hm, DebugActiveProcessStop); + GPA (hm, DebugBreakProcess); + GPA (hm, DebugSetProcessKillOnExit); + GPA (hm, GetConsoleFontSize); + GPA (hm, DebugActiveProcessStop); + GPA (hm, GetCurrentConsoleFont); } /* Set variables to dummy versions of these processes if the function @@ -2894,12 +3271,10 @@ _initialize_loadable (void) hm = LoadLibrary ("psapi.dll"); if (hm) { - EnumProcessModules = (void *) - GetProcAddress (hm, "EnumProcessModules"); - GetModuleInformation = (void *) - GetProcAddress (hm, "GetModuleInformation"); - GetModuleFileNameEx = (void *) - GetProcAddress (hm, GetModuleFileNameEx_name); + GPA (hm, EnumProcessModules); + GPA (hm, GetModuleInformation); + GetModuleFileNameEx = (GetModuleFileNameEx_ftype *) + GetProcAddress (hm, GetModuleFileNameEx_name); } if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx) @@ -2919,15 +3294,15 @@ Use \"file\" or \"dll\" command to load executable/libraries directly.")); hm = LoadLibrary ("advapi32.dll"); if (hm) { - OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken"); - LookupPrivilegeValueA = (void *) - GetProcAddress (hm, "LookupPrivilegeValueA"); - AdjustTokenPrivileges = (void *) - GetProcAddress (hm, "AdjustTokenPrivileges"); + GPA (hm, OpenProcessToken); + GPA (hm, LookupPrivilegeValueA); + GPA (hm, AdjustTokenPrivileges); /* Only need to set one of these since if OpenProcessToken fails nothing else is needed. */ if (!OpenProcessToken || !LookupPrivilegeValueA || !AdjustTokenPrivileges) OpenProcessToken = bad_OpenProcessToken; } + +#undef GPA }