1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2014 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 */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
44 #include <sys/cygwin.h>
45 #include <cygwin/version.h>
49 #include "filenames.h"
53 #include "gdb_obstack.h"
55 #include "gdbthread.h"
61 #include "xml-support.h"
63 #include "i386-tdep.h"
64 #include "i387-tdep.h"
66 #include "windows-tdep.h"
67 #include "windows-nat.h"
69 #include "complaints.h"
70 #include "inf-child.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);
100 #undef GetModuleFileNameEx
103 # define __PMAX (MAX_PATH + 1)
104 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
105 # define STARTUPINFO STARTUPINFOA
106 # define CreateProcess CreateProcessA
107 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
108 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
110 # define __PMAX PATH_MAX
111 /* The starting and ending address of the cygwin1.dll text segment. */
112 static CORE_ADDR cygwin_load_start;
113 static CORE_ADDR cygwin_load_end;
115 typedef wchar_t cygwin_buf_t;
116 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE,
118 # define STARTUPINFO STARTUPINFOW
119 # define CreateProcess CreateProcessW
120 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
121 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
124 static int have_saved_context; /* True if we've saved context from a
126 static CONTEXT saved_context; /* Containes the saved context from a
129 /* If we're not using the old Cygwin header file set, define the
130 following which never should have been in the generic Win32 API
131 headers in the first place since they were our own invention... */
132 #ifndef _GNU_H_WINDOWS_H
135 FLAG_TRACE_BIT = 0x100,
136 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
140 #ifndef CONTEXT_EXTENDED_REGISTERS
141 /* This macro is only defined on ia32. It only makes sense on this target,
142 so define it as zero if not already defined. */
143 #define CONTEXT_EXTENDED_REGISTERS 0
146 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
147 | CONTEXT_EXTENDED_REGISTERS
149 static uintptr_t dr[8];
150 static int debug_registers_changed;
151 static int debug_registers_used;
153 static int windows_initialization_done;
154 #define DR6_CLEAR_VALUE 0xffff0ff0
156 /* The string sent by cygwin when it processes a signal.
157 FIXME: This should be in a cygwin include file. */
158 #ifndef _CYGWIN_SIGNAL_STRING
159 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
162 #define CHECK(x) check (x, __FILE__,__LINE__)
163 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
164 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
165 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
166 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
168 static void windows_stop (struct target_ops *self, ptid_t);
169 static int windows_thread_alive (struct target_ops *, ptid_t);
170 static void windows_kill_inferior (struct target_ops *);
172 static void cygwin_set_dr (int i, CORE_ADDR addr);
173 static void cygwin_set_dr7 (unsigned long val);
174 static CORE_ADDR cygwin_get_dr (int i);
175 static unsigned long cygwin_get_dr6 (void);
176 static unsigned long cygwin_get_dr7 (void);
178 static enum gdb_signal last_sig = GDB_SIGNAL_0;
179 /* Set if a signal was received from the debugged process. */
181 /* Thread information structure used to track information that is
182 not available in gdb's thread structure. */
183 typedef struct thread_info_struct
185 struct thread_info_struct *next;
188 CORE_ADDR thread_local_base;
197 static thread_info thread_head;
199 /* The process and thread handles for the above context. */
201 static DEBUG_EVENT current_event; /* The current debug event from
203 static HANDLE current_process_handle; /* Currently executing process */
204 static thread_info *current_thread; /* Info on currently selected thread */
205 static DWORD main_thread_id; /* Thread ID of the main thread */
207 /* Counts of things. */
208 static int exception_count = 0;
209 static int event_count = 0;
210 static int saw_create;
211 static int open_process_used = 0;
214 static int new_console = 0;
216 static int cygwin_exceptions = 0;
218 static int new_group = 1;
219 static int debug_exec = 0; /* show execution */
220 static int debug_events = 0; /* show events from kernel */
221 static int debug_memory = 0; /* show target memory accesses */
222 static int debug_exceptions = 0; /* show target exceptions */
223 static int useshell = 0; /* use shell for subprocesses */
225 /* This vector maps GDB's idea of a register's number into an offset
226 in the windows exception context vector.
228 It also contains the bit mask needed to load the register in question.
230 The contents of this table can only be computed by the units
231 that provide CPU-specific support for Windows native debugging.
232 These units should set the table by calling
233 windows_set_context_register_offsets.
235 One day we could read a reg, we could inspect the context we
236 already have loaded, if it doesn't have the bit set that we need,
237 we read that set of registers in using GetThreadContext. If the
238 context already contains what we need, we just unpack it. Then to
239 write a register, first we have to ensure that the context contains
240 the other regs of the group, and then we copy the info in and set
243 static const int *mappings;
245 /* The function to use in order to determine whether a register is
246 a segment register or not. */
247 static segment_register_p_ftype *segment_register_p;
249 /* This vector maps the target's idea of an exception (extracted
250 from the DEBUG_EVENT structure) to GDB's idea. */
252 struct xlate_exception
258 static const struct xlate_exception
261 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
262 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
263 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
264 {DBG_CONTROL_C, GDB_SIGNAL_INT},
265 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
266 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
269 /* Set the MAPPINGS static global to OFFSETS.
270 See the description of MAPPINGS for more details. */
273 windows_set_context_register_offsets (const int *offsets)
278 /* See windows-nat.h. */
281 windows_set_segment_register_p (segment_register_p_ftype *fun)
283 segment_register_p = fun;
287 check (BOOL ok, const char *file, int line)
290 printf_filtered ("error return %s:%d was %u\n", file, line,
291 (unsigned) GetLastError ());
294 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
295 then also retrieve the context for this thread. If GET_CONTEXT is
296 negative, then don't suspend the thread. */
298 thread_rec (DWORD id, int get_context)
302 for (th = &thread_head; (th = th->next) != NULL;)
305 if (!th->suspended && get_context)
307 if (get_context > 0 && id != current_event.dwThreadId)
309 if (SuspendThread (th->h) == (DWORD) -1)
311 DWORD err = GetLastError ();
313 /* We get Access Denied (5) when trying to suspend
314 threads that Windows started on behalf of the
315 debuggee, usually when those threads are just
317 if (err != ERROR_ACCESS_DENIED)
318 warning (_("SuspendThread (tid=0x%x) failed."
320 (unsigned) id, (unsigned) err);
326 else if (get_context < 0)
328 th->reload_context = 1;
336 /* Add a thread to the thread list. */
338 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
343 gdb_assert (ptid_get_tid (ptid) != 0);
345 id = ptid_get_tid (ptid);
347 if ((th = thread_rec (id, FALSE)))
350 th = XCNEW (thread_info);
353 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
354 th->next = thread_head.next;
355 thread_head.next = th;
357 /* Set the debug registers for the new thread if they are used. */
358 if (debug_registers_used)
360 /* Only change the value of the debug registers. */
361 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
362 CHECK (GetThreadContext (th->h, &th->context));
363 th->context.Dr0 = dr[0];
364 th->context.Dr1 = dr[1];
365 th->context.Dr2 = dr[2];
366 th->context.Dr3 = dr[3];
367 th->context.Dr6 = DR6_CLEAR_VALUE;
368 th->context.Dr7 = dr[7];
369 CHECK (SetThreadContext (th->h, &th->context));
370 th->context.ContextFlags = 0;
375 /* Clear out any old thread list and reintialize it to a
378 windows_init_thread_list (void)
380 thread_info *th = &thread_head;
382 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
384 while (th->next != NULL)
386 thread_info *here = th->next;
387 th->next = here->next;
390 thread_head.next = NULL;
393 /* Delete a thread from the list of threads. */
395 windows_delete_thread (ptid_t ptid, DWORD exit_code)
400 gdb_assert (ptid_get_tid (ptid) != 0);
402 id = ptid_get_tid (ptid);
405 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
406 else if (print_thread_events && id != main_thread_id)
407 printf_unfiltered (_("[%s exited with code %u]\n"),
408 target_pid_to_str (ptid), (unsigned) exit_code);
409 delete_thread (ptid);
411 for (th = &thread_head;
412 th->next != NULL && th->next->id != id;
416 if (th->next != NULL)
418 thread_info *here = th->next;
419 th->next = here->next;
425 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
427 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
428 struct gdbarch *gdbarch = get_regcache_arch (regcache);
429 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
433 return; /* Windows sometimes uses a non-existent thread id in its
436 if (current_thread->reload_context)
438 #ifdef __COPY_CONTEXT_SIZE
439 if (have_saved_context)
441 /* Lie about where the program actually is stopped since
442 cygwin has informed us that we should consider the signal
443 to have occurred at another location which is stored in
445 memcpy (¤t_thread->context, &saved_context,
446 __COPY_CONTEXT_SIZE);
447 have_saved_context = 0;
452 thread_info *th = current_thread;
453 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
454 CHECK (GetThreadContext (th->h, &th->context));
455 /* Copy dr values from that thread.
456 But only if there were not modified since last stop.
458 if (!debug_registers_changed)
460 dr[0] = th->context.Dr0;
461 dr[1] = th->context.Dr1;
462 dr[2] = th->context.Dr2;
463 dr[3] = th->context.Dr3;
464 dr[6] = th->context.Dr6;
465 dr[7] = th->context.Dr7;
468 current_thread->reload_context = 0;
471 if (r == I387_FISEG_REGNUM (tdep))
473 l = *((long *) context_offset) & 0xffff;
474 regcache_raw_supply (regcache, r, (char *) &l);
476 else if (r == I387_FOP_REGNUM (tdep))
478 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
479 regcache_raw_supply (regcache, r, (char *) &l);
481 else if (segment_register_p (r))
483 /* GDB treats segment registers as 32bit registers, but they are
484 in fact only 16 bits long. Make sure we do not read extra
485 bits from our source buffer. */
486 l = *((long *) context_offset) & 0xffff;
487 regcache_raw_supply (regcache, r, (char *) &l);
490 regcache_raw_supply (regcache, r, context_offset);
493 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
494 do_windows_fetch_inferior_registers (regcache, r);
499 windows_fetch_inferior_registers (struct target_ops *ops,
500 struct regcache *regcache, int r)
502 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
503 /* Check if current_thread exists. Windows sometimes uses a non-existent
504 thread id in its events. */
506 do_windows_fetch_inferior_registers (regcache, r);
510 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
513 /* Windows sometimes uses a non-existent thread id in its events. */;
515 regcache_raw_collect (regcache, r,
516 ((char *) ¤t_thread->context) + mappings[r]);
519 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
520 do_windows_store_inferior_registers (regcache, r);
524 /* Store a new register value into the current thread context. */
526 windows_store_inferior_registers (struct target_ops *ops,
527 struct regcache *regcache, int r)
529 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
530 /* Check if current_thread exists. Windows sometimes uses a non-existent
531 thread id in its events. */
533 do_windows_store_inferior_registers (regcache, r);
536 /* Encapsulate the information required in a call to
537 symbol_file_add_args. */
538 struct safe_symbol_file_add_args
542 struct section_addr_info *addrs;
545 struct ui_file *err, *out;
549 /* Maintain a linked list of "so" information. */
555 static struct so_list solib_start, *solib_end;
557 /* Call symbol_file_add with stderr redirected. We don't care if there
560 safe_symbol_file_add_stub (void *argv)
562 #define p ((struct safe_symbol_file_add_args *) argv)
563 const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0)
564 | (p->mainline ? SYMFILE_MAINLINE : 0));
565 p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags);
570 /* Restore gdb's stderr after calling symbol_file_add. */
572 safe_symbol_file_add_cleanup (void *p)
574 #define sp ((struct safe_symbol_file_add_args *)p)
575 gdb_flush (gdb_stderr);
576 gdb_flush (gdb_stdout);
577 ui_file_delete (gdb_stderr);
578 ui_file_delete (gdb_stdout);
579 gdb_stderr = sp->err;
580 gdb_stdout = sp->out;
584 /* symbol_file_add wrapper that prevents errors from being displayed. */
585 static struct objfile *
586 safe_symbol_file_add (char *name, int from_tty,
587 struct section_addr_info *addrs,
588 int mainline, int flags)
590 struct safe_symbol_file_add_args p;
591 struct cleanup *cleanup;
593 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
597 gdb_flush (gdb_stderr);
598 gdb_flush (gdb_stdout);
599 gdb_stderr = ui_file_new ();
600 gdb_stdout = ui_file_new ();
602 p.from_tty = from_tty;
604 p.mainline = mainline;
606 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
608 do_cleanups (cleanup);
612 static struct so_list *
613 windows_make_so (const char *name, LPVOID load_addr)
620 WIN32_FIND_DATA w32_fd;
621 HANDLE h = FindFirstFile(name, &w32_fd);
623 if (h == INVALID_HANDLE_VALUE)
629 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
631 p = strrchr (buf, '\\');
634 SetCurrentDirectory (buf);
635 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
636 SetCurrentDirectory (cwd);
639 if (strcasecmp (buf, "ntdll.dll") == 0)
641 GetSystemDirectory (buf, sizeof (buf));
642 strcat (buf, "\\ntdll.dll");
645 cygwin_buf_t buf[__PMAX];
648 if (access (name, F_OK) != 0)
650 if (strcasecmp (name, "ntdll.dll") == 0)
653 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
654 wcscat (buf, L"\\ntdll.dll");
658 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
659 strcat (buf, "\\ntdll.dll");
664 so = XCNEW (struct so_list);
665 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
666 so->lm_info->load_addr = load_addr;
667 strcpy (so->so_original_name, name);
669 strcpy (so->so_name, buf);
672 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
673 SO_NAME_MAX_PATH_SIZE);
676 char *rname = realpath (name, NULL);
677 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
679 strcpy (so->so_name, rname);
683 error (_("dll path too long"));
685 /* Record cygwin1.dll .text start/end. */
686 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
687 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
690 asection *text = NULL;
693 abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);
698 if (bfd_check_format (abfd, bfd_object))
699 text = bfd_get_section_by_name (abfd, ".text");
703 gdb_bfd_unref (abfd);
707 /* The symbols in a dll are offset by 0x1000, which is the
708 offset from 0 of the first byte in an image - because of the
709 file header and the section alignment. */
710 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
712 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
714 gdb_bfd_unref (abfd);
722 get_image_name (HANDLE h, void *address, int unicode)
725 static char buf[__PMAX];
727 static char buf[(2 * __PMAX) + 1];
729 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
735 /* Attempt to read the name of the dll that was detected.
736 This is documented to work only when actively debugging
737 a program. It will not work for attached processes. */
741 /* See if we could read the address of a string, and that the
742 address isn't null. */
743 if (!ReadProcessMemory (h, address, &address_ptr,
744 sizeof (address_ptr), &done)
745 || done != sizeof (address_ptr) || !address_ptr)
748 /* Find the length of the string. */
749 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
750 && (b[0] != 0 || b[size - 1] != 0) && done == size)
754 ReadProcessMemory (h, address_ptr, buf, len, &done);
757 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
758 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
761 wcstombs (buf, unicode_address, __PMAX);
763 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
771 /* Handle a DLL load event, and return 1.
773 This function assumes that this event did not occur during inferior
774 initialization, where their event info may be incomplete (see
775 do_initial_windows_stuff and windows_add_all_dlls for more info
776 on how we handle DLL loading during that phase). */
779 handle_load_dll (void *dummy)
781 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
784 /* Try getting the DLL name via the lpImageName field of the event.
785 Note that Microsoft documents this fields as strictly optional,
786 in the sense that it might be NULL. And the first DLL event in
787 particular is explicitly documented as "likely not pass[ed]"
788 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
789 dll_name = get_image_name (current_process_handle,
790 event->lpImageName, event->fUnicode);
794 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
795 solib_end = solib_end->next;
797 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
798 host_address_to_string (solib_end->lm_info->load_addr)));
804 windows_free_so (struct so_list *so)
811 /* Handle a DLL unload event.
812 Return 1 if successful, or zero otherwise.
814 This function assumes that this event did not occur during inferior
815 initialization, where their event info may be incomplete (see
816 do_initial_windows_stuff and windows_add_all_dlls for more info
817 on how we handle DLL loading during that phase). */
820 handle_unload_dll (void *dummy)
822 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
825 for (so = &solib_start; so->next != NULL; so = so->next)
826 if (so->next->lm_info->load_addr == lpBaseOfDll)
828 struct so_list *sodel = so->next;
830 so->next = sodel->next;
833 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
835 windows_free_so (sodel);
839 /* We did not find any DLL that was previously loaded at this address,
840 so register a complaint. We do not report an error, because we have
841 observed that this may be happening under some circumstances. For
842 instance, running 32bit applications on x64 Windows causes us to receive
843 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
844 events are apparently caused by the WOW layer, the interface between
845 32bit and 64bit worlds). */
846 complaint (&symfile_complaints, _("dll starting at %s not found."),
847 host_address_to_string (lpBaseOfDll));
852 /* Clear list of loaded DLLs. */
854 windows_clear_solib (void)
856 solib_start.next = NULL;
857 solib_end = &solib_start;
860 /* Load DLL symbol info. */
862 dll_symbol_command (char *args, int from_tty)
868 error (_("dll-symbols requires a file name"));
871 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
873 char *newargs = (char *) alloca (n + 4 + 1);
874 strcpy (newargs, args);
875 strcat (newargs, ".dll");
879 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
882 /* Handle DEBUG_STRING output from child process.
883 Cygwin prepends its messages with a "cygwin:". Interpret this as
884 a Cygwin signal. Otherwise just print the string as a warning. */
886 handle_output_debug_string (struct target_waitstatus *ourstatus)
891 if (!target_read_string
892 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
896 else if (strncmp (s, _CYGWIN_SIGNAL_STRING,
897 sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
900 if (strncmp (s, "cYg", 3) != 0)
904 #ifdef __COPY_CONTEXT_SIZE
907 /* Got a cygwin signal marker. A cygwin signal is followed by
908 the signal number itself and then optionally followed by the
909 thread id and address to saved context within the DLL. If
910 these are supplied, then the given thread is assumed to have
911 issued the signal and the context from the thread is assumed
912 to be stored at the given address in the inferior. Tell gdb
913 to treat this like a real signal. */
915 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
916 int gotasig = gdb_signal_from_host (sig);
918 ourstatus->value.sig = gotasig;
924 ourstatus->kind = TARGET_WAITKIND_STOPPED;
925 retval = strtoul (p, &p, 0);
927 retval = main_thread_id;
928 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
929 && ReadProcessMemory (current_process_handle, x,
931 __COPY_CONTEXT_SIZE, &n)
932 && n == __COPY_CONTEXT_SIZE)
933 have_saved_context = 1;
934 current_event.dwThreadId = retval;
945 display_selector (HANDLE thread, DWORD sel)
948 if (GetThreadSelectorEntry (thread, sel, &info))
951 printf_filtered ("0x%03x: ", (unsigned) sel);
952 if (!info.HighWord.Bits.Pres)
954 puts_filtered ("Segment not present\n");
957 base = (info.HighWord.Bits.BaseHi << 24) +
958 (info.HighWord.Bits.BaseMid << 16)
960 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
961 if (info.HighWord.Bits.Granularity)
962 limit = (limit << 12) | 0xfff;
963 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
964 if (info.HighWord.Bits.Default_Big)
965 puts_filtered(" 32-bit ");
967 puts_filtered(" 16-bit ");
968 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
971 puts_filtered ("Data (Read-Only, Exp-up");
974 puts_filtered ("Data (Read/Write, Exp-up");
977 puts_filtered ("Unused segment (");
980 puts_filtered ("Data (Read/Write, Exp-down");
983 puts_filtered ("Code (Exec-Only, N.Conf");
986 puts_filtered ("Code (Exec/Read, N.Conf");
989 puts_filtered ("Code (Exec-Only, Conf");
992 puts_filtered ("Code (Exec/Read, Conf");
995 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
997 if ((info.HighWord.Bits.Type & 0x1) == 0)
998 puts_filtered(", N.Acc");
999 puts_filtered (")\n");
1000 if ((info.HighWord.Bits.Type & 0x10) == 0)
1001 puts_filtered("System selector ");
1002 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1003 if (info.HighWord.Bits.Granularity)
1004 puts_filtered ("Page granular.\n");
1006 puts_filtered ("Byte granular.\n");
1011 DWORD err = GetLastError ();
1012 if (err == ERROR_NOT_SUPPORTED)
1013 printf_filtered ("Function not supported\n");
1015 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1021 display_selectors (char * args, int from_tty)
1023 if (!current_thread)
1025 puts_filtered ("Impossible to display selectors now.\n");
1031 puts_filtered ("Selector $cs\n");
1032 display_selector (current_thread->h,
1033 current_thread->context.SegCs);
1034 puts_filtered ("Selector $ds\n");
1035 display_selector (current_thread->h,
1036 current_thread->context.SegDs);
1037 puts_filtered ("Selector $es\n");
1038 display_selector (current_thread->h,
1039 current_thread->context.SegEs);
1040 puts_filtered ("Selector $ss\n");
1041 display_selector (current_thread->h,
1042 current_thread->context.SegSs);
1043 puts_filtered ("Selector $fs\n");
1044 display_selector (current_thread->h,
1045 current_thread->context.SegFs);
1046 puts_filtered ("Selector $gs\n");
1047 display_selector (current_thread->h,
1048 current_thread->context.SegGs);
1053 sel = parse_and_eval_long (args);
1054 printf_filtered ("Selector \"%s\"\n",args);
1055 display_selector (current_thread->h, sel);
1059 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1060 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1061 host_address_to_string (\
1062 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1065 handle_exception (struct target_waitstatus *ourstatus)
1068 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1070 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1072 /* Record the context of the current thread. */
1073 th = thread_rec (current_event.dwThreadId, -1);
1077 case EXCEPTION_ACCESS_VIOLATION:
1078 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1079 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1082 /* See if the access violation happened within the cygwin DLL
1083 itself. Cygwin uses a kind of exception handling to deal
1084 with passed-in invalid addresses. gdb should not treat
1085 these as real SEGVs since they will be silently handled by
1086 cygwin. A real SEGV will (theoretically) be caught by
1087 cygwin later in the process and will be sent as a
1088 cygwin-specific-signal. So, ignore SEGVs if they show up
1089 within the text segment of the DLL itself. */
1091 CORE_ADDR addr = (CORE_ADDR) (uintptr_t)
1092 current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1094 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1095 && addr < cygwin_load_end))
1096 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1097 && strncmp (fn, "KERNEL32!IsBad",
1098 strlen ("KERNEL32!IsBad")) == 0))
1103 case STATUS_STACK_OVERFLOW:
1104 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1105 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1107 case STATUS_FLOAT_DENORMAL_OPERAND:
1108 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1109 ourstatus->value.sig = GDB_SIGNAL_FPE;
1111 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1112 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1113 ourstatus->value.sig = GDB_SIGNAL_FPE;
1115 case STATUS_FLOAT_INEXACT_RESULT:
1116 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1117 ourstatus->value.sig = GDB_SIGNAL_FPE;
1119 case STATUS_FLOAT_INVALID_OPERATION:
1120 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1121 ourstatus->value.sig = GDB_SIGNAL_FPE;
1123 case STATUS_FLOAT_OVERFLOW:
1124 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1125 ourstatus->value.sig = GDB_SIGNAL_FPE;
1127 case STATUS_FLOAT_STACK_CHECK:
1128 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1129 ourstatus->value.sig = GDB_SIGNAL_FPE;
1131 case STATUS_FLOAT_UNDERFLOW:
1132 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1133 ourstatus->value.sig = GDB_SIGNAL_FPE;
1135 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1136 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1137 ourstatus->value.sig = GDB_SIGNAL_FPE;
1139 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1140 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1141 ourstatus->value.sig = GDB_SIGNAL_FPE;
1143 case STATUS_INTEGER_OVERFLOW:
1144 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1145 ourstatus->value.sig = GDB_SIGNAL_FPE;
1147 case EXCEPTION_BREAKPOINT:
1148 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1149 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1152 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1153 ourstatus->value.sig = GDB_SIGNAL_INT;
1155 case DBG_CONTROL_BREAK:
1156 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1157 ourstatus->value.sig = GDB_SIGNAL_INT;
1159 case EXCEPTION_SINGLE_STEP:
1160 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1161 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1163 case EXCEPTION_ILLEGAL_INSTRUCTION:
1164 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1165 ourstatus->value.sig = GDB_SIGNAL_ILL;
1167 case EXCEPTION_PRIV_INSTRUCTION:
1168 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1169 ourstatus->value.sig = GDB_SIGNAL_ILL;
1171 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1172 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1173 ourstatus->value.sig = GDB_SIGNAL_ILL;
1176 /* Treat unhandled first chance exceptions specially. */
1177 if (current_event.u.Exception.dwFirstChance)
1179 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1180 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1181 host_address_to_string (
1182 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1183 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1187 last_sig = ourstatus->value.sig;
1191 /* Resume thread specified by ID, or all artificially suspended
1192 threads, if we are continuing execution. KILLED non-zero means we
1193 have killed the inferior, so we should ignore weird errors due to
1194 threads shutting down. */
1196 windows_continue (DWORD continue_status, int id, int killed)
1202 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1203 (unsigned) current_event.dwProcessId,
1204 (unsigned) current_event.dwThreadId,
1205 continue_status == DBG_CONTINUE ?
1206 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1208 for (th = &thread_head; (th = th->next) != NULL;)
1209 if ((id == -1 || id == (int) th->id)
1212 if (debug_registers_changed)
1214 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1215 th->context.Dr0 = dr[0];
1216 th->context.Dr1 = dr[1];
1217 th->context.Dr2 = dr[2];
1218 th->context.Dr3 = dr[3];
1219 th->context.Dr6 = DR6_CLEAR_VALUE;
1220 th->context.Dr7 = dr[7];
1222 if (th->context.ContextFlags)
1226 if (GetExitCodeThread (th->h, &ec)
1227 && ec == STILL_ACTIVE)
1229 BOOL status = SetThreadContext (th->h, &th->context);
1234 th->context.ContextFlags = 0;
1236 if (th->suspended > 0)
1237 (void) ResumeThread (th->h);
1241 res = ContinueDebugEvent (current_event.dwProcessId,
1242 current_event.dwThreadId,
1245 debug_registers_changed = 0;
1249 /* Called in pathological case where Windows fails to send a
1250 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1252 fake_create_process (void)
1254 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1255 current_event.dwProcessId);
1256 if (current_process_handle != NULL)
1257 open_process_used = 1;
1260 error (_("OpenProcess call failed, GetLastError = %u"),
1261 (unsigned) GetLastError ());
1262 /* We can not debug anything in that case. */
1264 main_thread_id = current_event.dwThreadId;
1265 current_thread = windows_add_thread (
1266 ptid_build (current_event.dwProcessId, 0,
1267 current_event.dwThreadId),
1268 current_event.u.CreateThread.hThread,
1269 current_event.u.CreateThread.lpThreadLocalBase);
1270 return main_thread_id;
1274 windows_resume (struct target_ops *ops,
1275 ptid_t ptid, int step, enum gdb_signal sig)
1278 DWORD continue_status = DBG_CONTINUE;
1280 /* A specific PTID means `step only this thread id'. */
1281 int resume_all = ptid_equal (ptid, minus_one_ptid);
1283 /* If we're continuing all threads, it's the current inferior that
1284 should be handled specially. */
1286 ptid = inferior_ptid;
1288 if (sig != GDB_SIGNAL_0)
1290 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1292 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1294 else if (sig == last_sig)
1295 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1298 /* This code does not seem to work, because
1299 the kernel does probably not consider changes in the ExceptionRecord
1300 structure when passing the exception to the inferior.
1301 Note that this seems possible in the exception handler itself. */
1304 for (i = 0; xlate[i].them != -1; i++)
1305 if (xlate[i].us == sig)
1307 current_event.u.Exception.ExceptionRecord.ExceptionCode
1309 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1312 if (continue_status == DBG_CONTINUE)
1314 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1318 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1322 last_sig = GDB_SIGNAL_0;
1324 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1325 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1327 /* Get context for currently selected thread. */
1328 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1333 /* Single step by setting t bit. */
1334 struct regcache *regcache = get_current_regcache ();
1335 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1336 windows_fetch_inferior_registers (ops, regcache,
1337 gdbarch_ps_regnum (gdbarch));
1338 th->context.EFlags |= FLAG_TRACE_BIT;
1341 if (th->context.ContextFlags)
1343 if (debug_registers_changed)
1345 th->context.Dr0 = dr[0];
1346 th->context.Dr1 = dr[1];
1347 th->context.Dr2 = dr[2];
1348 th->context.Dr3 = dr[3];
1349 th->context.Dr6 = DR6_CLEAR_VALUE;
1350 th->context.Dr7 = dr[7];
1352 CHECK (SetThreadContext (th->h, &th->context));
1353 th->context.ContextFlags = 0;
1357 /* Allow continuing with the same signal that interrupted us.
1358 Otherwise complain. */
1361 windows_continue (continue_status, -1, 0);
1363 windows_continue (continue_status, ptid_get_tid (ptid), 0);
1366 /* Ctrl-C handler used when the inferior is not run in the same console. The
1367 handler is in charge of interrupting the inferior using DebugBreakProcess.
1368 Note that this function is not available prior to Windows XP. In this case
1369 we emit a warning. */
1371 ctrl_c_handler (DWORD event_type)
1373 const int attach_flag = current_inferior ()->attach_flag;
1375 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1376 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1379 /* If the inferior and the debugger share the same console, do nothing as
1380 the inferior has also received the Ctrl-C event. */
1381 if (!new_console && !attach_flag)
1384 if (!DebugBreakProcess (current_process_handle))
1385 warning (_("Could not interrupt program. "
1386 "Press Ctrl-c in the program console."));
1388 /* Return true to tell that Ctrl-C has been handled. */
1392 /* Get the next event from the child. Return 1 if the event requires
1393 handling by WFI (or whatever). */
1395 get_windows_debug_event (struct target_ops *ops,
1396 int pid, struct target_waitstatus *ourstatus)
1399 DWORD continue_status, event_code;
1401 static thread_info dummy_thread_info;
1404 last_sig = GDB_SIGNAL_0;
1406 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1410 continue_status = DBG_CONTINUE;
1412 event_code = current_event.dwDebugEventCode;
1413 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1415 have_saved_context = 0;
1419 case CREATE_THREAD_DEBUG_EVENT:
1420 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1421 (unsigned) current_event.dwProcessId,
1422 (unsigned) current_event.dwThreadId,
1423 "CREATE_THREAD_DEBUG_EVENT"));
1424 if (saw_create != 1)
1426 struct inferior *inf;
1427 inf = find_inferior_pid (current_event.dwProcessId);
1428 if (!saw_create && inf->attach_flag)
1430 /* Kludge around a Windows bug where first event is a create
1431 thread event. Caused when attached process does not have
1433 retval = fake_create_process ();
1439 /* Record the existence of this thread. */
1440 retval = current_event.dwThreadId;
1441 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1442 current_event.dwThreadId),
1443 current_event.u.CreateThread.hThread,
1444 current_event.u.CreateThread.lpThreadLocalBase);
1448 case EXIT_THREAD_DEBUG_EVENT:
1449 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1450 (unsigned) current_event.dwProcessId,
1451 (unsigned) current_event.dwThreadId,
1452 "EXIT_THREAD_DEBUG_EVENT"));
1454 if (current_event.dwThreadId != main_thread_id)
1456 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1457 current_event.dwThreadId),
1458 current_event.u.ExitThread.dwExitCode);
1459 th = &dummy_thread_info;
1463 case CREATE_PROCESS_DEBUG_EVENT:
1464 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1465 (unsigned) current_event.dwProcessId,
1466 (unsigned) current_event.dwThreadId,
1467 "CREATE_PROCESS_DEBUG_EVENT"));
1468 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1469 if (++saw_create != 1)
1472 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1474 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1477 main_thread_id = current_event.dwThreadId;
1478 /* Add the main thread. */
1479 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1480 current_event.dwThreadId),
1481 current_event.u.CreateProcessInfo.hThread,
1482 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1483 retval = current_event.dwThreadId;
1486 case EXIT_PROCESS_DEBUG_EVENT:
1487 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1488 (unsigned) current_event.dwProcessId,
1489 (unsigned) current_event.dwThreadId,
1490 "EXIT_PROCESS_DEBUG_EVENT"));
1491 if (!windows_initialization_done)
1493 target_terminal_ours ();
1494 target_mourn_inferior ();
1495 error (_("During startup program exited with code 0x%x."),
1496 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1498 else if (saw_create == 1)
1500 ourstatus->kind = TARGET_WAITKIND_EXITED;
1501 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1502 retval = main_thread_id;
1506 case LOAD_DLL_DEBUG_EVENT:
1507 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1508 (unsigned) current_event.dwProcessId,
1509 (unsigned) current_event.dwThreadId,
1510 "LOAD_DLL_DEBUG_EVENT"));
1511 CloseHandle (current_event.u.LoadDll.hFile);
1512 if (saw_create != 1 || ! windows_initialization_done)
1514 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1515 ourstatus->kind = TARGET_WAITKIND_LOADED;
1516 ourstatus->value.integer = 0;
1517 retval = main_thread_id;
1520 case UNLOAD_DLL_DEBUG_EVENT:
1521 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1522 (unsigned) current_event.dwProcessId,
1523 (unsigned) current_event.dwThreadId,
1524 "UNLOAD_DLL_DEBUG_EVENT"));
1525 if (saw_create != 1 || ! windows_initialization_done)
1527 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1528 ourstatus->kind = TARGET_WAITKIND_LOADED;
1529 ourstatus->value.integer = 0;
1530 retval = main_thread_id;
1533 case EXCEPTION_DEBUG_EVENT:
1534 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1535 (unsigned) current_event.dwProcessId,
1536 (unsigned) current_event.dwThreadId,
1537 "EXCEPTION_DEBUG_EVENT"));
1538 if (saw_create != 1)
1540 switch (handle_exception (ourstatus))
1543 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1546 retval = current_event.dwThreadId;
1550 continue_status = -1;
1555 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1556 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1557 (unsigned) current_event.dwProcessId,
1558 (unsigned) current_event.dwThreadId,
1559 "OUTPUT_DEBUG_STRING_EVENT"));
1560 if (saw_create != 1)
1562 retval = handle_output_debug_string (ourstatus);
1566 if (saw_create != 1)
1568 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1569 (unsigned) current_event.dwProcessId,
1570 (unsigned) current_event.dwThreadId);
1571 printf_unfiltered (" unknown event code %u\n",
1572 (unsigned) current_event.dwDebugEventCode);
1576 if (!retval || saw_create != 1)
1578 if (continue_status == -1)
1579 windows_resume (ops, minus_one_ptid, 0, 1);
1581 CHECK (windows_continue (continue_status, -1, 0));
1585 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1587 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1594 /* Wait for interesting events to occur in the target process. */
1596 windows_wait (struct target_ops *ops,
1597 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1601 target_terminal_ours ();
1603 /* We loop when we get a non-standard exception rather than return
1604 with a SPURIOUS because resume can try and step or modify things,
1605 which needs a current_thread->h. But some of these exceptions mark
1606 the birth or death of threads, which mean that the current thread
1607 isn't necessarily what you think it is. */
1613 /* If the user presses Ctrl-c while the debugger is waiting
1614 for an event, he expects the debugger to interrupt his program
1615 and to get the prompt back. There are two possible situations:
1617 - The debugger and the program do not share the console, in
1618 which case the Ctrl-c event only reached the debugger.
1619 In that case, the ctrl_c handler will take care of interrupting
1620 the inferior. Note that this case is working starting with
1621 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1624 - The debugger and the program share the same console, in which
1625 case both debugger and inferior will receive the Ctrl-c event.
1626 In that case the ctrl_c handler will ignore the event, as the
1627 Ctrl-c event generated inside the inferior will trigger the
1628 expected debug event.
1630 FIXME: brobecker/2008-05-20: If the inferior receives the
1631 signal first and the delay until GDB receives that signal
1632 is sufficiently long, GDB can sometimes receive the SIGINT
1633 after we have unblocked the CTRL+C handler. This would
1634 lead to the debugger stopping prematurely while handling
1635 the new-thread event that comes with the handling of the SIGINT
1636 inside the inferior, and then stop again immediately when
1637 the user tries to resume the execution in the inferior.
1638 This is a classic race that we should try to fix one day. */
1639 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1640 retval = get_windows_debug_event (ops, pid, ourstatus);
1641 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1644 return ptid_build (current_event.dwProcessId, 0, retval);
1649 if (deprecated_ui_loop_hook != NULL)
1650 detach = deprecated_ui_loop_hook (0);
1653 windows_kill_inferior (ops);
1658 /* Iterate over all DLLs currently mapped by our inferior, and
1659 add them to our list of solibs. */
1662 windows_add_all_dlls (void)
1665 HMODULE dummy_hmodule;
1670 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1671 sizeof (HMODULE), &cb_needed) == 0)
1677 hmodules = (HMODULE *) alloca (cb_needed);
1678 if (EnumProcessModules (current_process_handle, hmodules,
1679 cb_needed, &cb_needed) == 0)
1682 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1686 wchar_t dll_name[__PMAX];
1689 char dll_name[__PMAX];
1692 if (GetModuleInformation (current_process_handle, hmodules[i],
1693 &mi, sizeof (mi)) == 0)
1695 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1696 dll_name, sizeof (dll_name)) == 0)
1699 wcstombs (name, dll_name, __PMAX);
1704 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1705 solib_end = solib_end->next;
1710 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1712 extern int stop_after_trap;
1714 struct inferior *inf;
1715 struct thread_info *tp;
1717 last_sig = GDB_SIGNAL_0;
1719 exception_count = 0;
1720 open_process_used = 0;
1721 debug_registers_changed = 0;
1722 debug_registers_used = 0;
1723 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1726 cygwin_load_start = cygwin_load_end = 0;
1728 current_event.dwProcessId = pid;
1729 memset (¤t_event, 0, sizeof (current_event));
1730 if (!target_is_pushed (ops))
1732 disable_breakpoints_in_shlibs ();
1733 windows_clear_solib ();
1734 clear_proceed_status ();
1735 init_wait_for_inferior ();
1737 inf = current_inferior ();
1738 inferior_appeared (inf, pid);
1739 inf->attach_flag = attaching;
1741 /* Make the new process the current inferior, so terminal handling
1742 can rely on it. When attaching, we don't know about any thread
1743 id here, but that's OK --- nothing should be referencing the
1744 current thread until we report an event out of windows_wait. */
1745 inferior_ptid = pid_to_ptid (pid);
1747 child_terminal_init_with_pgrp (pid);
1748 target_terminal_inferior ();
1750 windows_initialization_done = 0;
1751 inf->control.stop_soon = STOP_QUIETLY;
1754 stop_after_trap = 1;
1755 wait_for_inferior ();
1756 tp = inferior_thread ();
1757 if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP)
1758 resume (0, tp->suspend.stop_signal);
1763 /* Now that the inferior has been started and all DLLs have been mapped,
1764 we can iterate over all DLLs and load them in.
1766 We avoid doing it any earlier because, on certain versions of Windows,
1767 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1768 we have seen on Windows 8.1 that the ntdll.dll load event does not
1769 include the DLL name, preventing us from creating an associated SO.
1770 A possible explanation is that ntdll.dll might be mapped before
1771 the SO info gets created by the Windows system -- ntdll.dll is
1772 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1773 do not seem to suffer from that problem.
1775 Rather than try to work around this sort of issue, it is much
1776 simpler to just ignore DLL load/unload events during the startup
1777 phase, and then process them all in one batch now. */
1778 windows_add_all_dlls ();
1780 windows_initialization_done = 1;
1781 inf->control.stop_soon = NO_STOP_QUIETLY;
1782 stop_after_trap = 0;
1786 /* Try to set or remove a user privilege to the current process. Return -1
1787 if that fails, the previous setting of that privilege otherwise.
1789 This code is copied from the Cygwin source code and rearranged to allow
1790 dynamically loading of the needed symbols from advapi32 which is only
1791 available on NT/2K/XP. */
1793 set_process_privilege (const char *privilege, BOOL enable)
1795 HANDLE token_hdl = NULL;
1797 TOKEN_PRIVILEGES new_priv, orig_priv;
1801 if (!OpenProcessToken (GetCurrentProcess (),
1802 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1806 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1809 new_priv.PrivilegeCount = 1;
1810 new_priv.Privileges[0].Luid = restore_priv;
1811 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1813 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1814 sizeof orig_priv, &orig_priv, &size))
1817 /* Disabled, otherwise every `attach' in an unprivileged user session
1818 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1819 windows_attach(). */
1820 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1821 be enabled. GetLastError () returns an correct error code, though. */
1822 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1826 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1830 CloseHandle (token_hdl);
1835 /* Attach to process PID, then initialize for debugging it. */
1837 windows_attach (struct target_ops *ops, const char *args, int from_tty)
1842 pid = parse_pid_to_attach (args);
1844 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1846 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1847 printf_unfiltered ("This can cause attach to "
1848 "fail on Windows NT/2K/XP\n");
1851 windows_init_thread_list ();
1852 ok = DebugActiveProcess (pid);
1858 /* Try fall back to Cygwin pid. */
1859 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1862 ok = DebugActiveProcess (pid);
1867 error (_("Can't attach to process."));
1869 DebugSetProcessKillOnExit (FALSE);
1873 char *exec_file = (char *) get_exec_file (0);
1876 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1877 target_pid_to_str (pid_to_ptid (pid)));
1879 printf_unfiltered ("Attaching to %s\n",
1880 target_pid_to_str (pid_to_ptid (pid)));
1882 gdb_flush (gdb_stdout);
1885 do_initial_windows_stuff (ops, pid, 1);
1886 target_terminal_ours ();
1890 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1895 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1897 if (!DebugActiveProcessStop (current_event.dwProcessId))
1899 error (_("Can't detach process %u (error %u)"),
1900 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1903 DebugSetProcessKillOnExit (FALSE);
1905 if (detached && from_tty)
1907 char *exec_file = get_exec_file (0);
1910 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1911 (unsigned) current_event.dwProcessId);
1912 gdb_flush (gdb_stdout);
1915 i386_cleanup_dregs ();
1916 inferior_ptid = null_ptid;
1917 detach_inferior (current_event.dwProcessId);
1919 inf_child_maybe_unpush_target (ops);
1922 /* Try to determine the executable filename.
1924 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1926 Upon success, the filename is stored inside EXE_NAME_RET, and
1927 this function returns nonzero.
1929 Otherwise, this function returns zero and the contents of
1930 EXE_NAME_RET is undefined. */
1933 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1940 if (!EnumProcessModules (current_process_handle, &dh_buf,
1941 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1944 /* We know the executable is always first in the list of modules,
1945 which we just fetched. So no need to fetch more. */
1949 /* Cygwin prefers that the path be in /x/y/z format, so extract
1950 the filename into a temporary buffer first, and then convert it
1951 to POSIX format into the destination buffer. */
1952 cygwin_buf_t *pathbuf = alloca (exe_name_max_len * sizeof (cygwin_buf_t));
1954 len = GetModuleFileNameEx (current_process_handle,
1955 dh_buf, pathbuf, exe_name_max_len);
1957 error (_("Error getting executable filename: %u."),
1958 (unsigned) GetLastError ());
1959 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
1960 exe_name_max_len) < 0)
1961 error (_("Error converting executable filename to POSIX: %d."), errno);
1964 len = GetModuleFileNameEx (current_process_handle,
1965 dh_buf, exe_name_ret, exe_name_max_len);
1967 error (_("Error getting executable filename: %u."),
1968 (unsigned) GetLastError ());
1971 return 1; /* success */
1974 /* The pid_to_exec_file target_ops method for this platform. */
1977 windows_pid_to_exec_file (struct target_ops *self, int pid)
1979 static char path[__PMAX];
1981 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1983 char procexe[sizeof ("/proc/4294967295/exe")];
1985 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
1986 nchars = readlink (procexe, path, sizeof(path));
1987 if (nchars > 0 && nchars < sizeof (path))
1989 path[nchars] = '\0'; /* Got it */
1994 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1995 of gdb, or we're trying to debug a non-Cygwin windows executable. */
1996 if (!windows_get_exec_module_filename (path, sizeof (path)))
2002 /* Print status information about what we're accessing. */
2005 windows_files_info (struct target_ops *ignore)
2007 struct inferior *inf = current_inferior ();
2009 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2010 inf->attach_flag ? "attached" : "child",
2011 target_pid_to_str (inferior_ptid));
2014 /* Modify CreateProcess parameters for use of a new separate console.
2016 *FLAGS: DWORD parameter for general process creation flags.
2017 *SI: STARTUPINFO structure, for which the console window size and
2018 console buffer size is filled in if GDB is running in a console.
2019 to create the new console.
2020 The size of the used font is not available on all versions of
2021 Windows OS. Furthermore, the current font might not be the default
2022 font, but this is still better than before.
2023 If the windows and buffer sizes are computed,
2024 SI->DWFLAGS is changed so that this information is used
2025 by CreateProcess function. */
2028 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2030 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2031 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2033 if (hconsole != INVALID_HANDLE_VALUE)
2035 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2037 CONSOLE_FONT_INFO cfi;
2039 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2040 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2041 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2042 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2043 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2045 si->dwXSize *= font_size.X;
2049 si->dwYSize *= font_size.Y;
2052 si->dwXCountChars = sbinfo.dwSize.X;
2053 si->dwYCountChars = sbinfo.dwSize.Y;
2054 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2056 *flags |= CREATE_NEW_CONSOLE;
2060 /* Function called by qsort to sort environment strings. */
2063 envvar_cmp (const void *a, const void *b)
2065 const char **p = (const char **) a;
2066 const char **q = (const char **) b;
2067 return strcasecmp (*p, *q);
2073 clear_win32_environment (char **env)
2077 wchar_t *copy = NULL, *equalpos;
2079 for (i = 0; env[i] && *env[i]; i++)
2081 len = mbstowcs (NULL, env[i], 0) + 1;
2082 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2083 mbstowcs (copy, env[i], len);
2084 equalpos = wcschr (copy, L'=');
2087 SetEnvironmentVariableW (copy, NULL);
2093 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2094 EXEC_FILE is the file to run.
2095 ALLARGS is a string containing the arguments to the program.
2096 ENV is the environment vector to pass. Errors reported with error(). */
2099 windows_create_inferior (struct target_ops *ops, char *exec_file,
2100 char *allargs, char **in_env, int from_tty)
2104 cygwin_buf_t real_path[__PMAX];
2105 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2107 cygwin_buf_t *toexec;
2108 cygwin_buf_t *cygallargs;
2110 char **old_env = NULL;
2114 int ostdin, ostdout, ostderr;
2116 char real_path[__PMAX];
2117 char shell[__PMAX]; /* Path to shell */
2129 PROCESS_INFORMATION pi;
2132 const char *inferior_io_terminal = get_inferior_io_terminal ();
2135 error (_("No executable specified, use `target exec'."));
2137 memset (&si, 0, sizeof (si));
2138 si.cb = sizeof (si);
2141 flags |= CREATE_NEW_PROCESS_GROUP;
2144 windows_set_console_info (&si, &flags);
2149 flags |= DEBUG_ONLY_THIS_PROCESS;
2150 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2151 __PMAX * sizeof (cygwin_buf_t)) < 0)
2152 error (_("Error starting executable: %d"), errno);
2155 len = mbstowcs (NULL, allargs, 0) + 1;
2156 if (len == (size_t) -1)
2157 error (_("Error starting executable: %d"), errno);
2158 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2159 mbstowcs (cygallargs, allargs, len);
2161 cygallargs = allargs;
2166 sh = getenv ("SHELL");
2169 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2170 error (_("Error starting executable via shell: %d"), errno);
2172 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2173 + mbstowcs (NULL, allargs, 0) + 2;
2174 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2175 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2177 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2178 + strlen (allargs) + 2);
2179 cygallargs = (char *) alloca (len);
2180 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2183 flags |= DEBUG_PROCESS;
2187 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2188 * sizeof (wchar_t));
2189 wcscpy (args, toexec);
2190 wcscat (args, L" ");
2191 wcscat (args, cygallargs);
2193 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2194 strcpy (args, toexec);
2196 strcat (args, cygallargs);
2199 #ifdef CW_CVT_ENV_TO_WINENV
2200 /* First try to create a direct Win32 copy of the POSIX environment. */
2201 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2202 if (w32_env != (PWCHAR) -1)
2203 flags |= CREATE_UNICODE_ENVIRONMENT;
2205 /* If that fails, fall back to old method tweaking GDB's environment. */
2208 /* Reset all Win32 environment variables to avoid leftover on next run. */
2209 clear_win32_environment (environ);
2210 /* Prepare the environment vars for CreateProcess. */
2213 cygwin_internal (CW_SYNC_WINENV);
2217 if (!inferior_io_terminal)
2218 tty = ostdin = ostdout = ostderr = -1;
2221 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2224 print_sys_errmsg (inferior_io_terminal, errno);
2225 ostdin = ostdout = ostderr = -1;
2238 windows_init_thread_list ();
2239 ret = CreateProcess (0,
2240 args, /* command line */
2241 NULL, /* Security */
2243 TRUE, /* inherit handles */
2244 flags, /* start flags */
2245 w32_env, /* environment */
2246 NULL, /* current directory */
2250 /* Just free the Win32 environment, if it could be created. */
2254 /* Reset all environment variables to avoid leftover on next run. */
2255 clear_win32_environment (in_env);
2256 /* Restore normal GDB environment variables. */
2258 cygwin_internal (CW_SYNC_WINENV);
2273 /* Build the command line, a space-separated list of tokens where
2274 the first token is the name of the module to be executed.
2275 To avoid ambiguities introduced by spaces in the module name,
2277 args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
2278 args = alloca (args_len);
2279 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);
2281 flags |= DEBUG_ONLY_THIS_PROCESS;
2283 if (!inferior_io_terminal)
2284 tty = INVALID_HANDLE_VALUE;
2287 SECURITY_ATTRIBUTES sa;
2288 sa.nLength = sizeof(sa);
2289 sa.lpSecurityDescriptor = 0;
2290 sa.bInheritHandle = TRUE;
2291 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2292 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2293 if (tty == INVALID_HANDLE_VALUE)
2294 warning (_("Warning: Failed to open TTY %s, error %#x."),
2295 inferior_io_terminal, (unsigned) GetLastError ());
2299 si.hStdOutput = tty;
2301 si.dwFlags |= STARTF_USESTDHANDLES;
2305 /* CreateProcess takes the environment list as a null terminated set of
2306 strings (i.e. two nulls terminate the list). */
2308 /* Get total size for env strings. */
2309 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2310 envlen += strlen (in_env[i]) + 1;
2312 envsize = sizeof (in_env[0]) * (i + 1);
2313 env = (char **) alloca (envsize);
2314 memcpy (env, in_env, envsize);
2315 /* Windows programs expect the environment block to be sorted. */
2316 qsort (env, i, sizeof (char *), envvar_cmp);
2318 w32env = alloca (envlen + 1);
2320 /* Copy env strings into new buffer. */
2321 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2323 strcpy (temp, env[i]);
2324 temp += strlen (temp) + 1;
2327 /* Final nil string to terminate new env. */
2330 windows_init_thread_list ();
2331 ret = CreateProcessA (0,
2332 args, /* command line */
2333 NULL, /* Security */
2335 TRUE, /* inherit handles */
2336 flags, /* start flags */
2337 w32env, /* environment */
2338 NULL, /* current directory */
2341 if (tty != INVALID_HANDLE_VALUE)
2346 error (_("Error creating process %s, (error %u)."),
2347 exec_file, (unsigned) GetLastError ());
2349 CloseHandle (pi.hThread);
2350 CloseHandle (pi.hProcess);
2352 if (useshell && shell[0] != '\0')
2357 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2359 /* windows_continue (DBG_CONTINUE, -1, 0); */
2363 windows_mourn_inferior (struct target_ops *ops)
2365 (void) windows_continue (DBG_CONTINUE, -1, 0);
2366 i386_cleanup_dregs();
2367 if (open_process_used)
2369 CHECK (CloseHandle (current_process_handle));
2370 open_process_used = 0;
2372 inf_child_mourn_inferior (ops);
2375 /* Send a SIGINT to the process group. This acts just like the user typed a
2376 ^C on the controlling terminal. */
2379 windows_stop (struct target_ops *self, ptid_t ptid)
2381 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2382 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2383 registers_changed (); /* refresh register state */
2386 /* Helper for windows_xfer_partial that handles memory transfers.
2387 Arguments are like target_xfer_partial. */
2389 static enum target_xfer_status
2390 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2391 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2395 DWORD lasterror = 0;
2397 if (writebuf != NULL)
2399 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2400 pulongest (len), core_addr_to_string (memaddr)));
2401 success = WriteProcessMemory (current_process_handle,
2402 (LPVOID) (uintptr_t) memaddr, writebuf,
2405 lasterror = GetLastError ();
2406 FlushInstructionCache (current_process_handle,
2407 (LPCVOID) (uintptr_t) memaddr, len);
2411 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2412 pulongest (len), core_addr_to_string (memaddr)));
2413 success = ReadProcessMemory (current_process_handle,
2414 (LPCVOID) (uintptr_t) memaddr, readbuf,
2417 lasterror = GetLastError ();
2419 *xfered_len = (ULONGEST) done;
2420 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2421 return TARGET_XFER_OK;
2423 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2427 windows_kill_inferior (struct target_ops *ops)
2429 CHECK (TerminateProcess (current_process_handle, 0));
2433 if (!windows_continue (DBG_CONTINUE, -1, 1))
2435 if (!WaitForDebugEvent (¤t_event, INFINITE))
2437 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2441 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2445 windows_close (struct target_ops *self)
2447 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2448 ptid_get_pid (inferior_ptid)));
2451 /* Convert pid to printable format. */
2453 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2455 static char buf[80];
2457 if (ptid_get_tid (ptid) != 0)
2459 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2460 ptid_get_pid (ptid), ptid_get_tid (ptid));
2464 return normal_pid_to_str (ptid);
2467 static enum target_xfer_status
2468 windows_xfer_shared_libraries (struct target_ops *ops,
2469 enum target_object object, const char *annex,
2470 gdb_byte *readbuf, const gdb_byte *writebuf,
2471 ULONGEST offset, ULONGEST len,
2472 ULONGEST *xfered_len)
2474 struct obstack obstack;
2480 return TARGET_XFER_E_IO;
2482 obstack_init (&obstack);
2483 obstack_grow_str (&obstack, "<library-list>\n");
2484 for (so = solib_start.next; so; so = so->next)
2485 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2486 (uintptr_t) so->lm_info->load_addr,
2487 target_gdbarch (), &obstack);
2488 obstack_grow_str0 (&obstack, "</library-list>\n");
2490 buf = obstack_finish (&obstack);
2491 len_avail = strlen (buf);
2492 if (offset >= len_avail)
2496 if (len > len_avail - offset)
2497 len = len_avail - offset;
2498 memcpy (readbuf, buf + offset, len);
2501 obstack_free (&obstack, NULL);
2502 *xfered_len = (ULONGEST) len;
2503 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
2506 static enum target_xfer_status
2507 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2508 const char *annex, gdb_byte *readbuf,
2509 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2510 ULONGEST *xfered_len)
2514 case TARGET_OBJECT_MEMORY:
2515 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2517 case TARGET_OBJECT_LIBRARIES:
2518 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2519 writebuf, offset, len, xfered_len);
2522 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2523 readbuf, writebuf, offset, len,
2528 /* Provide thread local base, i.e. Thread Information Block address.
2529 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2532 windows_get_tib_address (struct target_ops *self,
2533 ptid_t ptid, CORE_ADDR *addr)
2537 th = thread_rec (ptid_get_tid (ptid), 0);
2542 *addr = th->thread_local_base;
2548 windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2550 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2553 static struct target_ops *
2554 windows_target (void)
2556 struct target_ops *t = inf_child_target ();
2558 t->to_close = windows_close;
2559 t->to_attach = windows_attach;
2560 t->to_attach_no_wait = 1;
2561 t->to_detach = windows_detach;
2562 t->to_resume = windows_resume;
2563 t->to_wait = windows_wait;
2564 t->to_fetch_registers = windows_fetch_inferior_registers;
2565 t->to_store_registers = windows_store_inferior_registers;
2566 t->to_xfer_partial = windows_xfer_partial;
2567 t->to_files_info = windows_files_info;
2568 t->to_kill = windows_kill_inferior;
2569 t->to_create_inferior = windows_create_inferior;
2570 t->to_mourn_inferior = windows_mourn_inferior;
2571 t->to_thread_alive = windows_thread_alive;
2572 t->to_pid_to_str = windows_pid_to_str;
2573 t->to_stop = windows_stop;
2574 t->to_pid_to_exec_file = windows_pid_to_exec_file;
2575 t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
2576 t->to_get_tib_address = windows_get_tib_address;
2582 set_windows_aliases (char *argv0)
2584 add_info_alias ("dll", "sharedlibrary", 1);
2587 /* -Wmissing-prototypes */
2588 extern initialize_file_ftype _initialize_windows_nat;
2591 _initialize_windows_nat (void)
2593 struct cmd_list_element *c;
2594 struct target_ops *t;
2596 t = windows_target ();
2598 i386_use_watchpoints (t);
2600 i386_dr_low.set_control = cygwin_set_dr7;
2601 i386_dr_low.set_addr = cygwin_set_dr;
2602 i386_dr_low.get_addr = cygwin_get_dr;
2603 i386_dr_low.get_status = cygwin_get_dr6;
2604 i386_dr_low.get_control = cygwin_get_dr7;
2606 /* i386_dr_low.debug_register_length field is set by
2607 calling i386_set_debug_register_length function
2608 in processor windows specific native file. */
2613 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2616 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2617 _("Load dll library symbols from FILE."));
2618 set_cmd_completer (c, filename_completer);
2619 deprecate_cmd (c, "sharedlibrary");
2621 c = add_com ("add-shared-symbol-files", class_files, dll_symbol_command,
2622 _("Load dll library symbols from FILE."));
2623 set_cmd_completer (c, filename_completer);
2624 deprecate_cmd (c, "sharedlibrary");
2626 c = add_com ("assf", class_files, dll_symbol_command,
2627 _("Load dll library symbols from FILE."));
2628 set_cmd_completer (c, filename_completer);
2629 deprecate_cmd (c, "sharedlibrary");
2632 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2633 Set use of shell to start subprocess."), _("\
2634 Show use of shell to start subprocess."), NULL,
2636 NULL, /* FIXME: i18n: */
2637 &setlist, &showlist);
2639 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2640 &cygwin_exceptions, _("\
2641 Break when an exception is detected in the Cygwin DLL itself."), _("\
2642 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2644 NULL, /* FIXME: i18n: */
2645 &setlist, &showlist);
2648 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2649 Set creation of new console when creating child process."), _("\
2650 Show creation of new console when creating child process."), NULL,
2652 NULL, /* FIXME: i18n: */
2653 &setlist, &showlist);
2655 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2656 Set creation of new group when creating child process."), _("\
2657 Show creation of new group when creating child process."), NULL,
2659 NULL, /* FIXME: i18n: */
2660 &setlist, &showlist);
2662 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2663 Set whether to display execution in child process."), _("\
2664 Show whether to display execution in child process."), NULL,
2666 NULL, /* FIXME: i18n: */
2667 &setlist, &showlist);
2669 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2670 Set whether to display kernel events in child process."), _("\
2671 Show whether to display kernel events in child process."), NULL,
2673 NULL, /* FIXME: i18n: */
2674 &setlist, &showlist);
2676 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2677 Set whether to display memory accesses in child process."), _("\
2678 Show whether to display memory accesses in child process."), NULL,
2680 NULL, /* FIXME: i18n: */
2681 &setlist, &showlist);
2683 add_setshow_boolean_cmd ("debugexceptions", class_support,
2684 &debug_exceptions, _("\
2685 Set whether to display kernel exceptions in child process."), _("\
2686 Show whether to display kernel exceptions in child process."), NULL,
2688 NULL, /* FIXME: i18n: */
2689 &setlist, &showlist);
2691 init_w32_command_list ();
2693 add_cmd ("selector", class_info, display_selectors,
2694 _("Display selectors infos."),
2696 deprecated_init_ui_hook = set_windows_aliases;
2699 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2701 /* Pass the address ADDR to the inferior in the I'th debug register.
2702 Here we just store the address in dr array, the registers will be
2703 actually set up when windows_continue is called. */
2705 cygwin_set_dr (int i, CORE_ADDR addr)
2708 internal_error (__FILE__, __LINE__,
2709 _("Invalid register %d in cygwin_set_dr.\n"), i);
2711 debug_registers_changed = 1;
2712 debug_registers_used = 1;
2715 /* Pass the value VAL to the inferior in the DR7 debug control
2716 register. Here we just store the address in D_REGS, the watchpoint
2717 will be actually set up in windows_wait. */
2719 cygwin_set_dr7 (unsigned long val)
2721 dr[7] = (CORE_ADDR) val;
2722 debug_registers_changed = 1;
2723 debug_registers_used = 1;
2726 /* Get the value of debug register I from the inferior. */
2729 cygwin_get_dr (int i)
2734 /* Get the value of the DR6 debug status register from the inferior.
2735 Here we just return the value stored in dr[6]
2736 by the last call to thread_rec for current_event.dwThreadId id. */
2737 static unsigned long
2738 cygwin_get_dr6 (void)
2740 return (unsigned long) dr[6];
2743 /* Get the value of the DR7 debug status register from the inferior.
2744 Here we just return the value stored in dr[7] by the last call to
2745 thread_rec for current_event.dwThreadId id. */
2747 static unsigned long
2748 cygwin_get_dr7 (void)
2750 return (unsigned long) dr[7];
2753 /* Determine if the thread referenced by "ptid" is alive
2754 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2755 it means that the thread has died. Otherwise it is assumed to be alive. */
2757 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2761 gdb_assert (ptid_get_tid (ptid) != 0);
2762 tid = ptid_get_tid (ptid);
2764 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
2768 /* -Wmissing-prototypes */
2769 extern initialize_file_ftype _initialize_check_for_gdb_ini;
2772 _initialize_check_for_gdb_ini (void)
2775 if (inhibit_gdbinit)
2778 homedir = getenv ("HOME");
2782 char *oldini = (char *) alloca (strlen (homedir) +
2783 sizeof ("/gdb.ini"));
2784 strcpy (oldini, homedir);
2785 p = strchr (oldini, '\0');
2786 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
2788 strcpy (p, "gdb.ini");
2789 if (access (oldini, 0) == 0)
2791 int len = strlen (oldini);
2792 char *newini = alloca (len + 1);
2794 xsnprintf (newini, len + 1, "%.*s.gdbinit",
2795 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2796 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2801 /* Define dummy functions which always return error for the rare cases where
2802 these functions could not be found. */
2804 bad_DebugActiveProcessStop (DWORD w)
2809 bad_DebugBreakProcess (HANDLE w)
2814 bad_DebugSetProcessKillOnExit (BOOL w)
2819 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2826 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2832 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2839 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2845 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2851 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
2857 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
2865 /* -Wmissing-prototypes */
2866 extern initialize_file_ftype _initialize_loadable;
2868 /* Load any functions which may not be available in ancient versions
2872 _initialize_loadable (void)
2876 hm = LoadLibrary ("kernel32.dll");
2879 DebugActiveProcessStop = (void *)
2880 GetProcAddress (hm, "DebugActiveProcessStop");
2881 DebugBreakProcess = (void *)
2882 GetProcAddress (hm, "DebugBreakProcess");
2883 DebugSetProcessKillOnExit = (void *)
2884 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2885 GetConsoleFontSize = (void *)
2886 GetProcAddress (hm, "GetConsoleFontSize");
2887 GetCurrentConsoleFont = (void *)
2888 GetProcAddress (hm, "GetCurrentConsoleFont");
2891 /* Set variables to dummy versions of these processes if the function
2892 wasn't found in kernel32.dll. */
2893 if (!DebugBreakProcess)
2894 DebugBreakProcess = bad_DebugBreakProcess;
2895 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2897 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2898 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2900 if (!GetConsoleFontSize)
2901 GetConsoleFontSize = bad_GetConsoleFontSize;
2902 if (!GetCurrentConsoleFont)
2903 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
2905 /* Load optional functions used for retrieving filename information
2906 associated with the currently debugged process or its dlls. */
2907 hm = LoadLibrary ("psapi.dll");
2910 EnumProcessModules = (void *)
2911 GetProcAddress (hm, "EnumProcessModules");
2912 GetModuleInformation = (void *)
2913 GetProcAddress (hm, "GetModuleInformation");
2914 GetModuleFileNameEx = (void *)
2915 GetProcAddress (hm, GetModuleFileNameEx_name);
2918 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2920 /* Set variables to dummy versions of these processes if the function
2921 wasn't found in psapi.dll. */
2922 EnumProcessModules = bad_EnumProcessModules;
2923 GetModuleInformation = bad_GetModuleInformation;
2924 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2925 /* This will probably fail on Windows 9x/Me. Let the user know
2926 that we're missing some functionality. */
2928 cannot automatically find executable file or library to read symbols.\n\
2929 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2932 hm = LoadLibrary ("advapi32.dll");
2935 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2936 LookupPrivilegeValueA = (void *)
2937 GetProcAddress (hm, "LookupPrivilegeValueA");
2938 AdjustTokenPrivileges = (void *)
2939 GetProcAddress (hm, "AdjustTokenPrivileges");
2940 /* Only need to set one of these since if OpenProcessToken fails nothing
2942 if (!OpenProcessToken || !LookupPrivilegeValueA
2943 || !AdjustTokenPrivileges)
2944 OpenProcessToken = bad_OpenProcessToken;