1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions, A Red Hat Company.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Originally by Steve Chamberlain, sac@cygnus.com */
25 #include "frame.h" /* required by inferior.h */
28 #include "exceptions.h"
31 #include "completer.h"
35 #include <sys/types.h>
43 #include <sys/cygwin.h>
44 #include <cygwin/version.h>
49 #include "filenames.h"
53 #include "gdb_obstack.h"
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"
71 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
72 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
73 #define DebugBreakProcess dyn_DebugBreakProcess
74 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
75 #define EnumProcessModules dyn_EnumProcessModules
76 #define GetModuleInformation dyn_GetModuleInformation
77 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
78 #define OpenProcessToken dyn_OpenProcessToken
79 #define GetConsoleFontSize dyn_GetConsoleFontSize
80 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
82 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
83 DWORD, PTOKEN_PRIVILEGES, PDWORD);
84 static BOOL WINAPI (*DebugActiveProcessStop) (DWORD);
85 static BOOL WINAPI (*DebugBreakProcess) (HANDLE);
86 static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL);
87 static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD,
89 static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
91 static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
92 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
93 static BOOL WINAPI (*GetCurrentConsoleFont) (HANDLE, BOOL,
95 static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD);
97 static struct target_ops windows_ops;
101 #undef GetModuleFileNameEx
104 # define __PMAX (MAX_PATH + 1)
105 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
106 # define STARTUPINFO STARTUPINFOA
107 # define CreateProcess CreateProcessA
108 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
109 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
111 # define __PMAX PATH_MAX
112 /* The starting and ending address of the cygwin1.dll text segment. */
113 static CORE_ADDR cygwin_load_start;
114 static CORE_ADDR cygwin_load_end;
116 typedef wchar_t cygwin_buf_t;
117 static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE,
119 # define STARTUPINFO STARTUPINFOW
120 # define CreateProcess CreateProcessW
121 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
122 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
125 static int have_saved_context; /* True if we've saved context from a
127 static CONTEXT saved_context; /* Containes the saved context from a
130 /* If we're not using the old Cygwin header file set, define the
131 following which never should have been in the generic Win32 API
132 headers in the first place since they were our own invention... */
133 #ifndef _GNU_H_WINDOWS_H
136 FLAG_TRACE_BIT = 0x100,
137 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
141 #ifndef CONTEXT_EXTENDED_REGISTERS
142 /* This macro is only defined on ia32. It only makes sense on this target,
143 so define it as zero if not already defined. */
144 #define CONTEXT_EXTENDED_REGISTERS 0
147 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
148 | CONTEXT_EXTENDED_REGISTERS
150 static uintptr_t dr[8];
151 static int debug_registers_changed;
152 static int debug_registers_used;
154 static int windows_initialization_done;
155 #define DR6_CLEAR_VALUE 0xffff0ff0
157 /* The string sent by cygwin when it processes a signal.
158 FIXME: This should be in a cygwin include file. */
159 #ifndef _CYGWIN_SIGNAL_STRING
160 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
163 #define CHECK(x) check (x, __FILE__,__LINE__)
164 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
165 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
166 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
167 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
169 static void windows_stop (ptid_t);
170 static int windows_thread_alive (struct target_ops *, ptid_t);
171 static void windows_kill_inferior (struct target_ops *);
173 static void cygwin_set_dr (int i, CORE_ADDR addr);
174 static void cygwin_set_dr7 (unsigned long val);
175 static CORE_ADDR cygwin_get_dr (int i);
176 static unsigned long cygwin_get_dr6 (void);
177 static unsigned long cygwin_get_dr7 (void);
179 static enum gdb_signal last_sig = GDB_SIGNAL_0;
180 /* Set if a signal was received from the debugged process. */
182 /* Thread information structure used to track information that is
183 not available in gdb's thread structure. */
184 typedef struct thread_info_struct
186 struct thread_info_struct *next;
189 CORE_ADDR thread_local_base;
198 static thread_info thread_head;
200 /* The process and thread handles for the above context. */
202 static DEBUG_EVENT current_event; /* The current debug event from
204 static HANDLE current_process_handle; /* Currently executing process */
205 static thread_info *current_thread; /* Info on currently selected thread */
206 static DWORD main_thread_id; /* Thread ID of the main thread */
208 /* Counts of things. */
209 static int exception_count = 0;
210 static int event_count = 0;
211 static int saw_create;
212 static int open_process_used = 0;
215 static int new_console = 0;
217 static int cygwin_exceptions = 0;
219 static int new_group = 1;
220 static int debug_exec = 0; /* show execution */
221 static int debug_events = 0; /* show events from kernel */
222 static int debug_memory = 0; /* show target memory accesses */
223 static int debug_exceptions = 0; /* show target exceptions */
224 static int useshell = 0; /* use shell for subprocesses */
226 /* This vector maps GDB's idea of a register's number into an offset
227 in the windows exception context vector.
229 It also contains the bit mask needed to load the register in question.
231 The contents of this table can only be computed by the units
232 that provide CPU-specific support for Windows native debugging.
233 These units should set the table by calling
234 windows_set_context_register_offsets.
236 One day we could read a reg, we could inspect the context we
237 already have loaded, if it doesn't have the bit set that we need,
238 we read that set of registers in using GetThreadContext. If the
239 context already contains what we need, we just unpack it. Then to
240 write a register, first we have to ensure that the context contains
241 the other regs of the group, and then we copy the info in and set
244 static const int *mappings;
246 /* The function to use in order to determine whether a register is
247 a segment register or not. */
248 static segment_register_p_ftype *segment_register_p;
250 /* This vector maps the target's idea of an exception (extracted
251 from the DEBUG_EVENT structure) to GDB's idea. */
253 struct xlate_exception
259 static const struct xlate_exception
262 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
263 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
264 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
265 {DBG_CONTROL_C, GDB_SIGNAL_INT},
266 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
267 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
270 /* Set the MAPPINGS static global to OFFSETS.
271 See the description of MAPPINGS for more details. */
274 windows_set_context_register_offsets (const int *offsets)
279 /* See windows-nat.h. */
282 windows_set_segment_register_p (segment_register_p_ftype *fun)
284 segment_register_p = fun;
288 check (BOOL ok, const char *file, int line)
291 printf_filtered ("error return %s:%d was %u\n", file, line,
292 (unsigned) GetLastError ());
295 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
296 then also retrieve the context for this thread. If GET_CONTEXT is
297 negative, then don't suspend the thread. */
299 thread_rec (DWORD id, int get_context)
303 for (th = &thread_head; (th = th->next) != NULL;)
306 if (!th->suspended && get_context)
308 if (get_context > 0 && id != current_event.dwThreadId)
310 if (SuspendThread (th->h) == (DWORD) -1)
312 DWORD err = GetLastError ();
314 warning (_("SuspendThread (tid=0x%x) failed."
316 (unsigned) id, (unsigned) err);
321 else if (get_context < 0)
323 th->reload_context = 1;
331 /* Add a thread to the thread list. */
333 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
338 gdb_assert (ptid_get_tid (ptid) != 0);
340 id = ptid_get_tid (ptid);
342 if ((th = thread_rec (id, FALSE)))
345 th = XZALLOC (thread_info);
348 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
349 th->next = thread_head.next;
350 thread_head.next = th;
352 /* Set the debug registers for the new thread if they are used. */
353 if (debug_registers_used)
355 /* Only change the value of the debug registers. */
356 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
357 CHECK (GetThreadContext (th->h, &th->context));
358 th->context.Dr0 = dr[0];
359 th->context.Dr1 = dr[1];
360 th->context.Dr2 = dr[2];
361 th->context.Dr3 = dr[3];
362 th->context.Dr6 = DR6_CLEAR_VALUE;
363 th->context.Dr7 = dr[7];
364 CHECK (SetThreadContext (th->h, &th->context));
365 th->context.ContextFlags = 0;
370 /* Clear out any old thread list and reintialize it to a
373 windows_init_thread_list (void)
375 thread_info *th = &thread_head;
377 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
379 while (th->next != NULL)
381 thread_info *here = th->next;
382 th->next = here->next;
385 thread_head.next = NULL;
388 /* Delete a thread from the list of threads. */
390 windows_delete_thread (ptid_t ptid, DWORD exit_code)
395 gdb_assert (ptid_get_tid (ptid) != 0);
397 id = ptid_get_tid (ptid);
400 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
401 else if (print_thread_events && id != main_thread_id)
402 printf_unfiltered (_("[%s exited with code %u]\n"),
403 target_pid_to_str (ptid), (unsigned) exit_code);
404 delete_thread (ptid);
406 for (th = &thread_head;
407 th->next != NULL && th->next->id != id;
411 if (th->next != NULL)
413 thread_info *here = th->next;
414 th->next = here->next;
420 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
422 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
423 struct gdbarch *gdbarch = get_regcache_arch (regcache);
424 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
428 return; /* Windows sometimes uses a non-existent thread id in its
431 if (current_thread->reload_context)
433 #ifdef __COPY_CONTEXT_SIZE
434 if (have_saved_context)
436 /* Lie about where the program actually is stopped since
437 cygwin has informed us that we should consider the signal
438 to have occurred at another location which is stored in
440 memcpy (¤t_thread->context, &saved_context,
441 __COPY_CONTEXT_SIZE);
442 have_saved_context = 0;
447 thread_info *th = current_thread;
448 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
449 GetThreadContext (th->h, &th->context);
450 /* Copy dr values from that thread.
451 But only if there were not modified since last stop.
453 if (!debug_registers_changed)
455 dr[0] = th->context.Dr0;
456 dr[1] = th->context.Dr1;
457 dr[2] = th->context.Dr2;
458 dr[3] = th->context.Dr3;
459 dr[6] = th->context.Dr6;
460 dr[7] = th->context.Dr7;
463 current_thread->reload_context = 0;
466 if (r == I387_FISEG_REGNUM (tdep))
468 l = *((long *) context_offset) & 0xffff;
469 regcache_raw_supply (regcache, r, (char *) &l);
471 else if (r == I387_FOP_REGNUM (tdep))
473 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
474 regcache_raw_supply (regcache, r, (char *) &l);
476 else if (segment_register_p (r))
478 /* GDB treats segment registers as 32bit registers, but they are
479 in fact only 16 bits long. Make sure we do not read extra
480 bits from our source buffer. */
481 l = *((long *) context_offset) & 0xffff;
482 regcache_raw_supply (regcache, r, (char *) &l);
485 regcache_raw_supply (regcache, r, context_offset);
488 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
489 do_windows_fetch_inferior_registers (regcache, r);
494 windows_fetch_inferior_registers (struct target_ops *ops,
495 struct regcache *regcache, int r)
497 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
498 /* Check if current_thread exists. Windows sometimes uses a non-existent
499 thread id in its events. */
501 do_windows_fetch_inferior_registers (regcache, r);
505 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
508 /* Windows sometimes uses a non-existent thread id in its events. */;
510 regcache_raw_collect (regcache, r,
511 ((char *) ¤t_thread->context) + mappings[r]);
514 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
515 do_windows_store_inferior_registers (regcache, r);
519 /* Store a new register value into the current thread context. */
521 windows_store_inferior_registers (struct target_ops *ops,
522 struct regcache *regcache, int r)
524 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
525 /* Check if current_thread exists. Windows sometimes uses a non-existent
526 thread id in its events. */
528 do_windows_store_inferior_registers (regcache, r);
531 /* Get the name of a given module at given base address. If base_address
532 is zero return the first loaded module (which is always the name of the
535 get_module_name (LPVOID base_address, char *dll_name_ret)
541 HMODULE *DllHandle = dh_buf; /* Set to temporary storage for
545 cygwin_buf_t pathbuf[__PMAX]; /* Temporary storage prior to converting to
546 posix form. __PMAX is always enough
547 as long as SO_NAME_MAX_PATH_SIZE is defined
552 /* Find size of buffer needed to handle list of modules loaded in
554 if (!EnumProcessModules (current_process_handle, DllHandle,
555 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
558 /* Allocate correct amount of space for module list. */
559 DllHandle = (HMODULE *) alloca (cbNeeded);
563 /* Get the list of modules. */
564 if (!EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
568 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
570 /* Get information on this module. */
571 if (!GetModuleInformation (current_process_handle, DllHandle[i],
573 error (_("Can't get module info"));
575 if (!base_address || mi.lpBaseOfDll == base_address)
577 /* Try to find the name of the given module. */
579 /* Cygwin prefers that the path be in /x/y/z format. */
580 len = GetModuleFileNameEx (current_process_handle,
581 DllHandle[i], pathbuf, __PMAX);
583 error (_("Error getting dll name: %u."),
584 (unsigned) GetLastError ());
585 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, dll_name_ret,
587 error (_("Error converting dll name to POSIX: %d."), errno);
589 len = GetModuleFileNameEx (current_process_handle,
590 DllHandle[i], dll_name_ret, __PMAX);
592 error (_("Error getting dll name: %u."),
593 (unsigned) GetLastError ());
595 return 1; /* success */
600 dll_name_ret[0] = '\0';
601 return 0; /* failure */
604 /* Encapsulate the information required in a call to
605 symbol_file_add_args. */
606 struct safe_symbol_file_add_args
610 struct section_addr_info *addrs;
613 struct ui_file *err, *out;
617 /* Maintain a linked list of "so" information. */
623 static struct so_list solib_start, *solib_end;
625 /* Call symbol_file_add with stderr redirected. We don't care if there
628 safe_symbol_file_add_stub (void *argv)
630 #define p ((struct safe_symbol_file_add_args *) argv)
631 const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0)
632 | (p->mainline ? SYMFILE_MAINLINE : 0));
633 p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags);
638 /* Restore gdb's stderr after calling symbol_file_add. */
640 safe_symbol_file_add_cleanup (void *p)
642 #define sp ((struct safe_symbol_file_add_args *)p)
643 gdb_flush (gdb_stderr);
644 gdb_flush (gdb_stdout);
645 ui_file_delete (gdb_stderr);
646 ui_file_delete (gdb_stdout);
647 gdb_stderr = sp->err;
648 gdb_stdout = sp->out;
652 /* symbol_file_add wrapper that prevents errors from being displayed. */
653 static struct objfile *
654 safe_symbol_file_add (char *name, int from_tty,
655 struct section_addr_info *addrs,
656 int mainline, int flags)
658 struct safe_symbol_file_add_args p;
659 struct cleanup *cleanup;
661 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
665 gdb_flush (gdb_stderr);
666 gdb_flush (gdb_stdout);
667 gdb_stderr = ui_file_new ();
668 gdb_stdout = ui_file_new ();
670 p.from_tty = from_tty;
672 p.mainline = mainline;
674 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
676 do_cleanups (cleanup);
680 static struct so_list *
681 windows_make_so (const char *name, LPVOID load_addr)
688 WIN32_FIND_DATA w32_fd;
689 HANDLE h = FindFirstFile(name, &w32_fd);
691 if (h == INVALID_HANDLE_VALUE)
697 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
699 p = strrchr (buf, '\\');
702 SetCurrentDirectory (buf);
703 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
704 SetCurrentDirectory (cwd);
707 if (strcasecmp (buf, "ntdll.dll") == 0)
709 GetSystemDirectory (buf, sizeof (buf));
710 strcat (buf, "\\ntdll.dll");
713 cygwin_buf_t buf[__PMAX];
716 if (access (name, F_OK) != 0)
718 if (strcasecmp (name, "ntdll.dll") == 0)
721 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
722 wcscat (buf, L"\\ntdll.dll");
726 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
727 strcat (buf, "\\ntdll.dll");
732 so = XZALLOC (struct so_list);
733 so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
734 so->lm_info->load_addr = load_addr;
735 strcpy (so->so_original_name, name);
737 strcpy (so->so_name, buf);
740 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
741 SO_NAME_MAX_PATH_SIZE);
744 char *rname = realpath (name, NULL);
745 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
747 strcpy (so->so_name, rname);
751 error (_("dll path too long"));
753 /* Record cygwin1.dll .text start/end. */
754 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
755 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
758 asection *text = NULL;
761 abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);
766 if (bfd_check_format (abfd, bfd_object))
767 text = bfd_get_section_by_name (abfd, ".text");
771 gdb_bfd_unref (abfd);
775 /* The symbols in a dll are offset by 0x1000, which is the
776 offset from 0 of the first byte in an image - because of the
777 file header and the section alignment. */
778 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
780 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
782 gdb_bfd_unref (abfd);
790 get_image_name (HANDLE h, void *address, int unicode)
793 static char buf[__PMAX];
795 static char buf[(2 * __PMAX) + 1];
797 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
803 /* Attempt to read the name of the dll that was detected.
804 This is documented to work only when actively debugging
805 a program. It will not work for attached processes. */
809 /* See if we could read the address of a string, and that the
810 address isn't null. */
811 if (!ReadProcessMemory (h, address, &address_ptr,
812 sizeof (address_ptr), &done)
813 || done != sizeof (address_ptr) || !address_ptr)
816 /* Find the length of the string. */
817 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
818 && (b[0] != 0 || b[size - 1] != 0) && done == size)
822 ReadProcessMemory (h, address_ptr, buf, len, &done);
825 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
826 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
829 wcstombs (buf, unicode_address, __PMAX);
831 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
839 /* Wait for child to do something. Return pid of child, or -1 in case
840 of error; store status through argument pointer OURSTATUS. */
842 handle_load_dll (void *dummy)
844 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
845 char dll_buf[__PMAX];
846 char *dll_name = NULL;
848 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
850 /* Try getting the DLL name by searching the list of known modules
851 and matching their base address against this new DLL's base address.
853 FIXME: brobecker/2013-12-10:
854 It seems odd to be going through this search if the DLL name could
855 simply be extracted via "event->lpImageName". Moreover, some
856 experimentation with various versions of Windows seem to indicate
857 that it might still be too early for this DLL to be listed when
858 querying the system about the current list of modules, thus making
859 this attempt pointless.
861 This code can therefore probably be removed. But at the time of
862 this writing, we are too close to creating the GDB 7.7 branch
863 for us to make such a change. We are therefore defering it. */
865 if (!get_module_name (event->lpBaseOfDll, dll_buf))
866 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
870 /* Try getting the DLL name via the lpImageName field of the event.
871 Note that Microsoft documents this fields as strictly optional,
872 in the sense that it might be NULL. And the first DLL event in
873 particular is explicitly documented as "likely not pass[ed]"
874 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
875 if (*dll_name == '\0')
876 dll_name = get_image_name (current_process_handle,
877 event->lpImageName, event->fUnicode);
881 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
882 solib_end = solib_end->next;
884 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
885 host_address_to_string (solib_end->lm_info->load_addr)));
891 windows_free_so (struct so_list *so)
899 handle_unload_dll (void *dummy)
901 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
904 for (so = &solib_start; so->next != NULL; so = so->next)
905 if (so->next->lm_info->load_addr == lpBaseOfDll)
907 struct so_list *sodel = so->next;
909 so->next = sodel->next;
912 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
914 windows_free_so (sodel);
918 /* We did not find any DLL that was previously loaded at this address,
919 so register a complaint. We do not report an error, because we have
920 observed that this may be happening under some circumstances. For
921 instance, running 32bit applications on x64 Windows causes us to receive
922 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
923 events are apparently caused by the WOW layer, the interface between
924 32bit and 64bit worlds). */
925 complaint (&symfile_complaints, _("dll starting at %s not found."),
926 host_address_to_string (lpBaseOfDll));
931 /* Clear list of loaded DLLs. */
933 windows_clear_solib (void)
935 solib_start.next = NULL;
936 solib_end = &solib_start;
939 /* Load DLL symbol info. */
941 dll_symbol_command (char *args, int from_tty)
947 error (_("dll-symbols requires a file name"));
950 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
952 char *newargs = (char *) alloca (n + 4 + 1);
953 strcpy (newargs, args);
954 strcat (newargs, ".dll");
958 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
961 /* Handle DEBUG_STRING output from child process.
962 Cygwin prepends its messages with a "cygwin:". Interpret this as
963 a Cygwin signal. Otherwise just print the string as a warning. */
965 handle_output_debug_string (struct target_waitstatus *ourstatus)
970 if (!target_read_string
971 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
975 else if (strncmp (s, _CYGWIN_SIGNAL_STRING,
976 sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
979 if (strncmp (s, "cYg", 3) != 0)
983 #ifdef __COPY_CONTEXT_SIZE
986 /* Got a cygwin signal marker. A cygwin signal is followed by
987 the signal number itself and then optionally followed by the
988 thread id and address to saved context within the DLL. If
989 these are supplied, then the given thread is assumed to have
990 issued the signal and the context from the thread is assumed
991 to be stored at the given address in the inferior. Tell gdb
992 to treat this like a real signal. */
994 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
995 int gotasig = gdb_signal_from_host (sig);
997 ourstatus->value.sig = gotasig;
1003 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1004 retval = strtoul (p, &p, 0);
1006 retval = main_thread_id;
1007 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
1008 && ReadProcessMemory (current_process_handle, x,
1010 __COPY_CONTEXT_SIZE, &n)
1011 && n == __COPY_CONTEXT_SIZE)
1012 have_saved_context = 1;
1013 current_event.dwThreadId = retval;
1024 display_selector (HANDLE thread, DWORD sel)
1027 if (GetThreadSelectorEntry (thread, sel, &info))
1030 printf_filtered ("0x%03x: ", (unsigned) sel);
1031 if (!info.HighWord.Bits.Pres)
1033 puts_filtered ("Segment not present\n");
1036 base = (info.HighWord.Bits.BaseHi << 24) +
1037 (info.HighWord.Bits.BaseMid << 16)
1039 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
1040 if (info.HighWord.Bits.Granularity)
1041 limit = (limit << 12) | 0xfff;
1042 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
1043 if (info.HighWord.Bits.Default_Big)
1044 puts_filtered(" 32-bit ");
1046 puts_filtered(" 16-bit ");
1047 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
1050 puts_filtered ("Data (Read-Only, Exp-up");
1053 puts_filtered ("Data (Read/Write, Exp-up");
1056 puts_filtered ("Unused segment (");
1059 puts_filtered ("Data (Read/Write, Exp-down");
1062 puts_filtered ("Code (Exec-Only, N.Conf");
1065 puts_filtered ("Code (Exec/Read, N.Conf");
1068 puts_filtered ("Code (Exec-Only, Conf");
1071 puts_filtered ("Code (Exec/Read, Conf");
1074 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
1076 if ((info.HighWord.Bits.Type & 0x1) == 0)
1077 puts_filtered(", N.Acc");
1078 puts_filtered (")\n");
1079 if ((info.HighWord.Bits.Type & 0x10) == 0)
1080 puts_filtered("System selector ");
1081 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1082 if (info.HighWord.Bits.Granularity)
1083 puts_filtered ("Page granular.\n");
1085 puts_filtered ("Byte granular.\n");
1090 DWORD err = GetLastError ();
1091 if (err == ERROR_NOT_SUPPORTED)
1092 printf_filtered ("Function not supported\n");
1094 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1100 display_selectors (char * args, int from_tty)
1102 if (!current_thread)
1104 puts_filtered ("Impossible to display selectors now.\n");
1110 puts_filtered ("Selector $cs\n");
1111 display_selector (current_thread->h,
1112 current_thread->context.SegCs);
1113 puts_filtered ("Selector $ds\n");
1114 display_selector (current_thread->h,
1115 current_thread->context.SegDs);
1116 puts_filtered ("Selector $es\n");
1117 display_selector (current_thread->h,
1118 current_thread->context.SegEs);
1119 puts_filtered ("Selector $ss\n");
1120 display_selector (current_thread->h,
1121 current_thread->context.SegSs);
1122 puts_filtered ("Selector $fs\n");
1123 display_selector (current_thread->h,
1124 current_thread->context.SegFs);
1125 puts_filtered ("Selector $gs\n");
1126 display_selector (current_thread->h,
1127 current_thread->context.SegGs);
1132 sel = parse_and_eval_long (args);
1133 printf_filtered ("Selector \"%s\"\n",args);
1134 display_selector (current_thread->h, sel);
1138 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1139 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1140 host_address_to_string (\
1141 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1144 handle_exception (struct target_waitstatus *ourstatus)
1147 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1149 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1151 /* Record the context of the current thread. */
1152 th = thread_rec (current_event.dwThreadId, -1);
1156 case EXCEPTION_ACCESS_VIOLATION:
1157 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1158 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1161 /* See if the access violation happened within the cygwin DLL
1162 itself. Cygwin uses a kind of exception handling to deal
1163 with passed-in invalid addresses. gdb should not treat
1164 these as real SEGVs since they will be silently handled by
1165 cygwin. A real SEGV will (theoretically) be caught by
1166 cygwin later in the process and will be sent as a
1167 cygwin-specific-signal. So, ignore SEGVs if they show up
1168 within the text segment of the DLL itself. */
1170 CORE_ADDR addr = (CORE_ADDR) (uintptr_t)
1171 current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1173 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1174 && addr < cygwin_load_end))
1175 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1176 && strncmp (fn, "KERNEL32!IsBad",
1177 strlen ("KERNEL32!IsBad")) == 0))
1182 case STATUS_STACK_OVERFLOW:
1183 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1184 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1186 case STATUS_FLOAT_DENORMAL_OPERAND:
1187 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1188 ourstatus->value.sig = GDB_SIGNAL_FPE;
1190 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1191 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1192 ourstatus->value.sig = GDB_SIGNAL_FPE;
1194 case STATUS_FLOAT_INEXACT_RESULT:
1195 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1196 ourstatus->value.sig = GDB_SIGNAL_FPE;
1198 case STATUS_FLOAT_INVALID_OPERATION:
1199 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1200 ourstatus->value.sig = GDB_SIGNAL_FPE;
1202 case STATUS_FLOAT_OVERFLOW:
1203 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1204 ourstatus->value.sig = GDB_SIGNAL_FPE;
1206 case STATUS_FLOAT_STACK_CHECK:
1207 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1208 ourstatus->value.sig = GDB_SIGNAL_FPE;
1210 case STATUS_FLOAT_UNDERFLOW:
1211 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1212 ourstatus->value.sig = GDB_SIGNAL_FPE;
1214 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1215 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1216 ourstatus->value.sig = GDB_SIGNAL_FPE;
1218 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1219 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1220 ourstatus->value.sig = GDB_SIGNAL_FPE;
1222 case STATUS_INTEGER_OVERFLOW:
1223 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1224 ourstatus->value.sig = GDB_SIGNAL_FPE;
1226 case EXCEPTION_BREAKPOINT:
1227 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1228 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1231 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1232 ourstatus->value.sig = GDB_SIGNAL_INT;
1234 case DBG_CONTROL_BREAK:
1235 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1236 ourstatus->value.sig = GDB_SIGNAL_INT;
1238 case EXCEPTION_SINGLE_STEP:
1239 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1240 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1242 case EXCEPTION_ILLEGAL_INSTRUCTION:
1243 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1244 ourstatus->value.sig = GDB_SIGNAL_ILL;
1246 case EXCEPTION_PRIV_INSTRUCTION:
1247 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1248 ourstatus->value.sig = GDB_SIGNAL_ILL;
1250 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1251 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1252 ourstatus->value.sig = GDB_SIGNAL_ILL;
1255 /* Treat unhandled first chance exceptions specially. */
1256 if (current_event.u.Exception.dwFirstChance)
1258 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1259 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1260 host_address_to_string (
1261 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1262 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1266 last_sig = ourstatus->value.sig;
1270 /* Resume all artificially suspended threads if we are continuing
1273 windows_continue (DWORD continue_status, int id)
1279 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1280 (unsigned) current_event.dwProcessId,
1281 (unsigned) current_event.dwThreadId,
1282 continue_status == DBG_CONTINUE ?
1283 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1285 for (th = &thread_head; (th = th->next) != NULL;)
1286 if ((id == -1 || id == (int) th->id)
1289 if (debug_registers_changed)
1291 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1292 th->context.Dr0 = dr[0];
1293 th->context.Dr1 = dr[1];
1294 th->context.Dr2 = dr[2];
1295 th->context.Dr3 = dr[3];
1296 th->context.Dr6 = DR6_CLEAR_VALUE;
1297 th->context.Dr7 = dr[7];
1299 if (th->context.ContextFlags)
1301 CHECK (SetThreadContext (th->h, &th->context));
1302 th->context.ContextFlags = 0;
1304 if (th->suspended > 0)
1305 (void) ResumeThread (th->h);
1309 res = ContinueDebugEvent (current_event.dwProcessId,
1310 current_event.dwThreadId,
1313 debug_registers_changed = 0;
1317 /* Called in pathological case where Windows fails to send a
1318 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1320 fake_create_process (void)
1322 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1323 current_event.dwProcessId);
1324 if (current_process_handle != NULL)
1325 open_process_used = 1;
1328 error (_("OpenProcess call failed, GetLastError = %u"),
1329 (unsigned) GetLastError ());
1330 /* We can not debug anything in that case. */
1332 main_thread_id = current_event.dwThreadId;
1333 current_thread = windows_add_thread (
1334 ptid_build (current_event.dwProcessId, 0,
1335 current_event.dwThreadId),
1336 current_event.u.CreateThread.hThread,
1337 current_event.u.CreateThread.lpThreadLocalBase);
1338 return main_thread_id;
1342 windows_resume (struct target_ops *ops,
1343 ptid_t ptid, int step, enum gdb_signal sig)
1346 DWORD continue_status = DBG_CONTINUE;
1348 /* A specific PTID means `step only this thread id'. */
1349 int resume_all = ptid_equal (ptid, minus_one_ptid);
1351 /* If we're continuing all threads, it's the current inferior that
1352 should be handled specially. */
1354 ptid = inferior_ptid;
1356 if (sig != GDB_SIGNAL_0)
1358 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1360 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1362 else if (sig == last_sig)
1363 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1366 /* This code does not seem to work, because
1367 the kernel does probably not consider changes in the ExceptionRecord
1368 structure when passing the exception to the inferior.
1369 Note that this seems possible in the exception handler itself. */
1372 for (i = 0; xlate[i].them != -1; i++)
1373 if (xlate[i].us == sig)
1375 current_event.u.Exception.ExceptionRecord.ExceptionCode
1377 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1380 if (continue_status == DBG_CONTINUE)
1382 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1386 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1390 last_sig = GDB_SIGNAL_0;
1392 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1393 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1395 /* Get context for currently selected thread. */
1396 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1401 /* Single step by setting t bit. */
1402 struct regcache *regcache = get_current_regcache ();
1403 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1404 windows_fetch_inferior_registers (ops, regcache,
1405 gdbarch_ps_regnum (gdbarch));
1406 th->context.EFlags |= FLAG_TRACE_BIT;
1409 if (th->context.ContextFlags)
1411 if (debug_registers_changed)
1413 th->context.Dr0 = dr[0];
1414 th->context.Dr1 = dr[1];
1415 th->context.Dr2 = dr[2];
1416 th->context.Dr3 = dr[3];
1417 th->context.Dr6 = DR6_CLEAR_VALUE;
1418 th->context.Dr7 = dr[7];
1420 CHECK (SetThreadContext (th->h, &th->context));
1421 th->context.ContextFlags = 0;
1425 /* Allow continuing with the same signal that interrupted us.
1426 Otherwise complain. */
1429 windows_continue (continue_status, -1);
1431 windows_continue (continue_status, ptid_get_tid (ptid));
1434 /* Ctrl-C handler used when the inferior is not run in the same console. The
1435 handler is in charge of interrupting the inferior using DebugBreakProcess.
1436 Note that this function is not available prior to Windows XP. In this case
1437 we emit a warning. */
1439 ctrl_c_handler (DWORD event_type)
1441 const int attach_flag = current_inferior ()->attach_flag;
1443 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1444 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1447 /* If the inferior and the debugger share the same console, do nothing as
1448 the inferior has also received the Ctrl-C event. */
1449 if (!new_console && !attach_flag)
1452 if (!DebugBreakProcess (current_process_handle))
1453 warning (_("Could not interrupt program. "
1454 "Press Ctrl-c in the program console."));
1456 /* Return true to tell that Ctrl-C has been handled. */
1460 /* Get the next event from the child. Return 1 if the event requires
1461 handling by WFI (or whatever). */
1463 get_windows_debug_event (struct target_ops *ops,
1464 int pid, struct target_waitstatus *ourstatus)
1467 DWORD continue_status, event_code;
1469 static thread_info dummy_thread_info;
1472 last_sig = GDB_SIGNAL_0;
1474 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1478 continue_status = DBG_CONTINUE;
1480 event_code = current_event.dwDebugEventCode;
1481 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1483 have_saved_context = 0;
1487 case CREATE_THREAD_DEBUG_EVENT:
1488 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1489 (unsigned) current_event.dwProcessId,
1490 (unsigned) current_event.dwThreadId,
1491 "CREATE_THREAD_DEBUG_EVENT"));
1492 if (saw_create != 1)
1494 struct inferior *inf;
1495 inf = find_inferior_pid (current_event.dwProcessId);
1496 if (!saw_create && inf->attach_flag)
1498 /* Kludge around a Windows bug where first event is a create
1499 thread event. Caused when attached process does not have
1501 retval = fake_create_process ();
1507 /* Record the existence of this thread. */
1508 retval = current_event.dwThreadId;
1509 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1510 current_event.dwThreadId),
1511 current_event.u.CreateThread.hThread,
1512 current_event.u.CreateThread.lpThreadLocalBase);
1516 case EXIT_THREAD_DEBUG_EVENT:
1517 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1518 (unsigned) current_event.dwProcessId,
1519 (unsigned) current_event.dwThreadId,
1520 "EXIT_THREAD_DEBUG_EVENT"));
1522 if (current_event.dwThreadId != main_thread_id)
1524 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1525 current_event.dwThreadId),
1526 current_event.u.ExitThread.dwExitCode);
1527 th = &dummy_thread_info;
1531 case CREATE_PROCESS_DEBUG_EVENT:
1532 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1533 (unsigned) current_event.dwProcessId,
1534 (unsigned) current_event.dwThreadId,
1535 "CREATE_PROCESS_DEBUG_EVENT"));
1536 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1537 if (++saw_create != 1)
1540 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1542 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1545 main_thread_id = current_event.dwThreadId;
1546 /* Add the main thread. */
1547 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1548 current_event.dwThreadId),
1549 current_event.u.CreateProcessInfo.hThread,
1550 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1551 retval = current_event.dwThreadId;
1554 case EXIT_PROCESS_DEBUG_EVENT:
1555 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1556 (unsigned) current_event.dwProcessId,
1557 (unsigned) current_event.dwThreadId,
1558 "EXIT_PROCESS_DEBUG_EVENT"));
1559 if (!windows_initialization_done)
1561 target_terminal_ours ();
1562 target_mourn_inferior ();
1563 error (_("During startup program exited with code 0x%x."),
1564 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1566 else if (saw_create == 1)
1568 ourstatus->kind = TARGET_WAITKIND_EXITED;
1569 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1570 retval = main_thread_id;
1574 case LOAD_DLL_DEBUG_EVENT:
1575 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1576 (unsigned) current_event.dwProcessId,
1577 (unsigned) current_event.dwThreadId,
1578 "LOAD_DLL_DEBUG_EVENT"));
1579 CloseHandle (current_event.u.LoadDll.hFile);
1580 if (saw_create != 1)
1582 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1583 ourstatus->kind = TARGET_WAITKIND_LOADED;
1584 ourstatus->value.integer = 0;
1585 retval = main_thread_id;
1588 case UNLOAD_DLL_DEBUG_EVENT:
1589 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1590 (unsigned) current_event.dwProcessId,
1591 (unsigned) current_event.dwThreadId,
1592 "UNLOAD_DLL_DEBUG_EVENT"));
1593 if (saw_create != 1)
1595 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1596 ourstatus->kind = TARGET_WAITKIND_LOADED;
1597 ourstatus->value.integer = 0;
1598 retval = main_thread_id;
1601 case EXCEPTION_DEBUG_EVENT:
1602 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1603 (unsigned) current_event.dwProcessId,
1604 (unsigned) current_event.dwThreadId,
1605 "EXCEPTION_DEBUG_EVENT"));
1606 if (saw_create != 1)
1608 switch (handle_exception (ourstatus))
1611 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1614 retval = current_event.dwThreadId;
1618 continue_status = -1;
1623 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1624 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1625 (unsigned) current_event.dwProcessId,
1626 (unsigned) current_event.dwThreadId,
1627 "OUTPUT_DEBUG_STRING_EVENT"));
1628 if (saw_create != 1)
1630 retval = handle_output_debug_string (ourstatus);
1634 if (saw_create != 1)
1636 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1637 (unsigned) current_event.dwProcessId,
1638 (unsigned) current_event.dwThreadId);
1639 printf_unfiltered (" unknown event code %u\n",
1640 (unsigned) current_event.dwDebugEventCode);
1644 if (!retval || saw_create != 1)
1646 if (continue_status == -1)
1647 windows_resume (ops, minus_one_ptid, 0, 1);
1649 CHECK (windows_continue (continue_status, -1));
1653 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1655 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1662 /* Wait for interesting events to occur in the target process. */
1664 windows_wait (struct target_ops *ops,
1665 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1669 target_terminal_ours ();
1671 /* We loop when we get a non-standard exception rather than return
1672 with a SPURIOUS because resume can try and step or modify things,
1673 which needs a current_thread->h. But some of these exceptions mark
1674 the birth or death of threads, which mean that the current thread
1675 isn't necessarily what you think it is. */
1681 /* If the user presses Ctrl-c while the debugger is waiting
1682 for an event, he expects the debugger to interrupt his program
1683 and to get the prompt back. There are two possible situations:
1685 - The debugger and the program do not share the console, in
1686 which case the Ctrl-c event only reached the debugger.
1687 In that case, the ctrl_c handler will take care of interrupting
1688 the inferior. Note that this case is working starting with
1689 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1692 - The debugger and the program share the same console, in which
1693 case both debugger and inferior will receive the Ctrl-c event.
1694 In that case the ctrl_c handler will ignore the event, as the
1695 Ctrl-c event generated inside the inferior will trigger the
1696 expected debug event.
1698 FIXME: brobecker/2008-05-20: If the inferior receives the
1699 signal first and the delay until GDB receives that signal
1700 is sufficiently long, GDB can sometimes receive the SIGINT
1701 after we have unblocked the CTRL+C handler. This would
1702 lead to the debugger stopping prematurely while handling
1703 the new-thread event that comes with the handling of the SIGINT
1704 inside the inferior, and then stop again immediately when
1705 the user tries to resume the execution in the inferior.
1706 This is a classic race that we should try to fix one day. */
1707 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1708 retval = get_windows_debug_event (ops, pid, ourstatus);
1709 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1712 return ptid_build (current_event.dwProcessId, 0, retval);
1717 if (deprecated_ui_loop_hook != NULL)
1718 detach = deprecated_ui_loop_hook (0);
1721 windows_kill_inferior (ops);
1726 /* On certain versions of Windows, the information about ntdll.dll
1727 is not available yet at the time we get the LOAD_DLL_DEBUG_EVENT,
1728 thus preventing us from reporting this DLL as an SO. This has been
1729 witnessed on Windows 8.1, for instance. A possible explanation
1730 is that ntdll.dll might be mapped before the SO info gets created
1731 by the Windows system -- ntdll.dll is the first DLL to be reported
1732 via LOAD_DLL_DEBUG_EVENT and other DLLs do not seem to suffer from
1735 If we indeed are missing ntdll.dll, this function tries to recover
1736 from this issue, after the fact. Do nothing if we encounter any
1737 issue trying to locate that DLL. */
1740 windows_ensure_ntdll_loaded (void)
1743 HMODULE dummy_hmodule;
1748 for (so = solib_start.next; so != NULL; so = so->next)
1749 if (FILENAME_CMP (lbasename (so->so_name), "ntdll.dll") == 0)
1750 return; /* ntdll.dll already loaded, nothing to do. */
1752 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1753 sizeof (HMODULE), &cb_needed) == 0)
1759 hmodules = (HMODULE *) alloca (cb_needed);
1760 if (EnumProcessModules (current_process_handle, hmodules,
1761 cb_needed, &cb_needed) == 0)
1764 for (i = 0; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1767 char dll_name[__PMAX];
1769 if (GetModuleInformation (current_process_handle, hmodules[i],
1770 &mi, sizeof (mi)) == 0)
1772 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1773 dll_name, sizeof (dll_name)) == 0)
1775 if (FILENAME_CMP (lbasename (dll_name), "ntdll.dll") == 0)
1777 solib_end->next = windows_make_so (dll_name, mi.lpBaseOfDll);
1778 solib_end = solib_end->next;
1785 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1787 extern int stop_after_trap;
1789 struct inferior *inf;
1790 struct thread_info *tp;
1792 last_sig = GDB_SIGNAL_0;
1794 exception_count = 0;
1795 open_process_used = 0;
1796 debug_registers_changed = 0;
1797 debug_registers_used = 0;
1798 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1801 cygwin_load_start = cygwin_load_end = 0;
1803 current_event.dwProcessId = pid;
1804 memset (¤t_event, 0, sizeof (current_event));
1806 disable_breakpoints_in_shlibs ();
1807 windows_clear_solib ();
1808 clear_proceed_status ();
1809 init_wait_for_inferior ();
1811 inf = current_inferior ();
1812 inferior_appeared (inf, pid);
1813 inf->attach_flag = attaching;
1815 /* Make the new process the current inferior, so terminal handling
1816 can rely on it. When attaching, we don't know about any thread
1817 id here, but that's OK --- nothing should be referencing the
1818 current thread until we report an event out of windows_wait. */
1819 inferior_ptid = pid_to_ptid (pid);
1821 terminal_init_inferior_with_pgrp (pid);
1822 target_terminal_inferior ();
1824 windows_initialization_done = 0;
1825 inf->control.stop_soon = STOP_QUIETLY;
1828 stop_after_trap = 1;
1829 wait_for_inferior ();
1830 tp = inferior_thread ();
1831 if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP)
1832 resume (0, tp->suspend.stop_signal);
1837 /* FIXME: brobecker/2013-12-10: We should try another approach where
1838 we first ignore all DLL load/unload events up until this point,
1839 and then iterate over all modules to create the associated shared
1840 objects. This is a fairly significant change, however, and we are
1841 close to creating a release branch, so we are delaying it a bit,
1842 after the branch is created. */
1843 windows_ensure_ntdll_loaded ();
1845 windows_initialization_done = 1;
1846 inf->control.stop_soon = NO_STOP_QUIETLY;
1847 stop_after_trap = 0;
1851 /* Try to set or remove a user privilege to the current process. Return -1
1852 if that fails, the previous setting of that privilege otherwise.
1854 This code is copied from the Cygwin source code and rearranged to allow
1855 dynamically loading of the needed symbols from advapi32 which is only
1856 available on NT/2K/XP. */
1858 set_process_privilege (const char *privilege, BOOL enable)
1860 HANDLE token_hdl = NULL;
1862 TOKEN_PRIVILEGES new_priv, orig_priv;
1866 if (!OpenProcessToken (GetCurrentProcess (),
1867 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1871 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1874 new_priv.PrivilegeCount = 1;
1875 new_priv.Privileges[0].Luid = restore_priv;
1876 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1878 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1879 sizeof orig_priv, &orig_priv, &size))
1882 /* Disabled, otherwise every `attach' in an unprivileged user session
1883 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1884 windows_attach(). */
1885 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1886 be enabled. GetLastError () returns an correct error code, though. */
1887 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1891 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1895 CloseHandle (token_hdl);
1900 /* Attach to process PID, then initialize for debugging it. */
1902 windows_attach (struct target_ops *ops, char *args, int from_tty)
1907 pid = parse_pid_to_attach (args);
1909 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1911 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1912 printf_unfiltered ("This can cause attach to "
1913 "fail on Windows NT/2K/XP\n");
1916 windows_init_thread_list ();
1917 ok = DebugActiveProcess (pid);
1923 /* Try fall back to Cygwin pid. */
1924 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1927 ok = DebugActiveProcess (pid);
1932 error (_("Can't attach to process."));
1934 DebugSetProcessKillOnExit (FALSE);
1938 char *exec_file = (char *) get_exec_file (0);
1941 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1942 target_pid_to_str (pid_to_ptid (pid)));
1944 printf_unfiltered ("Attaching to %s\n",
1945 target_pid_to_str (pid_to_ptid (pid)));
1947 gdb_flush (gdb_stdout);
1950 do_initial_windows_stuff (ops, pid, 1);
1951 target_terminal_ours ();
1955 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1960 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1962 if (!DebugActiveProcessStop (current_event.dwProcessId))
1964 error (_("Can't detach process %u (error %u)"),
1965 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1968 DebugSetProcessKillOnExit (FALSE);
1970 if (detached && from_tty)
1972 char *exec_file = get_exec_file (0);
1975 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1976 (unsigned) current_event.dwProcessId);
1977 gdb_flush (gdb_stdout);
1980 i386_cleanup_dregs ();
1981 inferior_ptid = null_ptid;
1982 detach_inferior (current_event.dwProcessId);
1984 unpush_target (ops);
1988 windows_pid_to_exec_file (int pid)
1990 static char path[__PMAX];
1992 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
1994 char procexe[sizeof ("/proc/4294967295/exe")];
1996 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
1997 nchars = readlink (procexe, path, sizeof(path));
1998 if (nchars > 0 && nchars < sizeof (path))
2000 path[nchars] = '\0'; /* Got it */
2005 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2006 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2007 if (!get_module_name (0, path))
2013 /* Print status information about what we're accessing. */
2016 windows_files_info (struct target_ops *ignore)
2018 struct inferior *inf = current_inferior ();
2020 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2021 inf->attach_flag ? "attached" : "child",
2022 target_pid_to_str (inferior_ptid));
2026 windows_open (char *arg, int from_tty)
2028 error (_("Use the \"run\" command to start a Unix child process."));
2031 /* Modify CreateProcess parameters for use of a new separate console.
2033 *FLAGS: DWORD parameter for general process creation flags.
2034 *SI: STARTUPINFO structure, for which the console window size and
2035 console buffer size is filled in if GDB is running in a console.
2036 to create the new console.
2037 The size of the used font is not available on all versions of
2038 Windows OS. Furthermore, the current font might not be the default
2039 font, but this is still better than before.
2040 If the windows and buffer sizes are computed,
2041 SI->DWFLAGS is changed so that this information is used
2042 by CreateProcess function. */
2045 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2047 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2048 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2050 if (hconsole != INVALID_HANDLE_VALUE)
2052 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2054 CONSOLE_FONT_INFO cfi;
2056 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2057 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2058 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2059 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2060 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2062 si->dwXSize *= font_size.X;
2066 si->dwYSize *= font_size.Y;
2069 si->dwXCountChars = sbinfo.dwSize.X;
2070 si->dwYCountChars = sbinfo.dwSize.Y;
2071 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2073 *flags |= CREATE_NEW_CONSOLE;
2077 /* Function called by qsort to sort environment strings. */
2080 envvar_cmp (const void *a, const void *b)
2082 const char **p = (const char **) a;
2083 const char **q = (const char **) b;
2084 return strcasecmp (*p, *q);
2090 clear_win32_environment (char **env)
2094 wchar_t *copy = NULL, *equalpos;
2096 for (i = 0; env[i] && *env[i]; i++)
2098 len = mbstowcs (NULL, env[i], 0) + 1;
2099 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2100 mbstowcs (copy, env[i], len);
2101 equalpos = wcschr (copy, L'=');
2104 SetEnvironmentVariableW (copy, NULL);
2110 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2111 EXEC_FILE is the file to run.
2112 ALLARGS is a string containing the arguments to the program.
2113 ENV is the environment vector to pass. Errors reported with error(). */
2116 windows_create_inferior (struct target_ops *ops, char *exec_file,
2117 char *allargs, char **in_env, int from_tty)
2121 cygwin_buf_t real_path[__PMAX];
2122 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2124 cygwin_buf_t *toexec;
2125 cygwin_buf_t *cygallargs;
2127 char **old_env = NULL;
2131 int ostdin, ostdout, ostderr;
2133 char real_path[__PMAX];
2134 char shell[__PMAX]; /* Path to shell */
2146 PROCESS_INFORMATION pi;
2149 const char *inferior_io_terminal = get_inferior_io_terminal ();
2152 error (_("No executable specified, use `target exec'."));
2154 memset (&si, 0, sizeof (si));
2155 si.cb = sizeof (si);
2158 flags |= CREATE_NEW_PROCESS_GROUP;
2161 windows_set_console_info (&si, &flags);
2166 flags |= DEBUG_ONLY_THIS_PROCESS;
2167 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2168 __PMAX * sizeof (cygwin_buf_t)) < 0)
2169 error (_("Error starting executable: %d"), errno);
2172 len = mbstowcs (NULL, allargs, 0) + 1;
2173 if (len == (size_t) -1)
2174 error (_("Error starting executable: %d"), errno);
2175 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2176 mbstowcs (cygallargs, allargs, len);
2178 cygallargs = allargs;
2183 sh = getenv ("SHELL");
2186 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2187 error (_("Error starting executable via shell: %d"), errno);
2189 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2190 + mbstowcs (NULL, allargs, 0) + 2;
2191 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2192 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2194 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2195 + strlen (allargs) + 2);
2196 cygallargs = (char *) alloca (len);
2197 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2200 flags |= DEBUG_PROCESS;
2204 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2205 * sizeof (wchar_t));
2206 wcscpy (args, toexec);
2207 wcscat (args, L" ");
2208 wcscat (args, cygallargs);
2210 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2211 strcpy (args, toexec);
2213 strcat (args, cygallargs);
2216 #ifdef CW_CVT_ENV_TO_WINENV
2217 /* First try to create a direct Win32 copy of the POSIX environment. */
2218 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2219 if (w32_env != (PWCHAR) -1)
2220 flags |= CREATE_UNICODE_ENVIRONMENT;
2222 /* If that fails, fall back to old method tweaking GDB's environment. */
2225 /* Reset all Win32 environment variables to avoid leftover on next run. */
2226 clear_win32_environment (environ);
2227 /* Prepare the environment vars for CreateProcess. */
2230 cygwin_internal (CW_SYNC_WINENV);
2234 if (!inferior_io_terminal)
2235 tty = ostdin = ostdout = ostderr = -1;
2238 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2241 print_sys_errmsg (inferior_io_terminal, errno);
2242 ostdin = ostdout = ostderr = -1;
2255 windows_init_thread_list ();
2256 ret = CreateProcess (0,
2257 args, /* command line */
2258 NULL, /* Security */
2260 TRUE, /* inherit handles */
2261 flags, /* start flags */
2262 w32_env, /* environment */
2263 NULL, /* current directory */
2267 /* Just free the Win32 environment, if it could be created. */
2271 /* Reset all environment variables to avoid leftover on next run. */
2272 clear_win32_environment (in_env);
2273 /* Restore normal GDB environment variables. */
2275 cygwin_internal (CW_SYNC_WINENV);
2290 /* Build the command line, a space-separated list of tokens where
2291 the first token is the name of the module to be executed.
2292 To avoid ambiguities introduced by spaces in the module name,
2294 args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
2295 args = alloca (args_len);
2296 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);
2298 flags |= DEBUG_ONLY_THIS_PROCESS;
2300 if (!inferior_io_terminal)
2301 tty = INVALID_HANDLE_VALUE;
2304 SECURITY_ATTRIBUTES sa;
2305 sa.nLength = sizeof(sa);
2306 sa.lpSecurityDescriptor = 0;
2307 sa.bInheritHandle = TRUE;
2308 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2309 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2310 if (tty == INVALID_HANDLE_VALUE)
2311 warning (_("Warning: Failed to open TTY %s, error %#x."),
2312 inferior_io_terminal, (unsigned) GetLastError ());
2316 si.hStdOutput = tty;
2318 si.dwFlags |= STARTF_USESTDHANDLES;
2322 /* CreateProcess takes the environment list as a null terminated set of
2323 strings (i.e. two nulls terminate the list). */
2325 /* Get total size for env strings. */
2326 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2327 envlen += strlen (in_env[i]) + 1;
2329 envsize = sizeof (in_env[0]) * (i + 1);
2330 env = (char **) alloca (envsize);
2331 memcpy (env, in_env, envsize);
2332 /* Windows programs expect the environment block to be sorted. */
2333 qsort (env, i, sizeof (char *), envvar_cmp);
2335 w32env = alloca (envlen + 1);
2337 /* Copy env strings into new buffer. */
2338 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2340 strcpy (temp, env[i]);
2341 temp += strlen (temp) + 1;
2344 /* Final nil string to terminate new env. */
2347 windows_init_thread_list ();
2348 ret = CreateProcessA (0,
2349 args, /* command line */
2350 NULL, /* Security */
2352 TRUE, /* inherit handles */
2353 flags, /* start flags */
2354 w32env, /* environment */
2355 NULL, /* current directory */
2358 if (tty != INVALID_HANDLE_VALUE)
2363 error (_("Error creating process %s, (error %u)."),
2364 exec_file, (unsigned) GetLastError ());
2366 CloseHandle (pi.hThread);
2367 CloseHandle (pi.hProcess);
2369 if (useshell && shell[0] != '\0')
2374 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2376 /* windows_continue (DBG_CONTINUE, -1); */
2380 windows_mourn_inferior (struct target_ops *ops)
2382 (void) windows_continue (DBG_CONTINUE, -1);
2383 i386_cleanup_dregs();
2384 if (open_process_used)
2386 CHECK (CloseHandle (current_process_handle));
2387 open_process_used = 0;
2389 unpush_target (ops);
2390 generic_mourn_inferior ();
2393 /* Send a SIGINT to the process group. This acts just like the user typed a
2394 ^C on the controlling terminal. */
2397 windows_stop (ptid_t ptid)
2399 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2400 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2401 registers_changed (); /* refresh register state */
2404 /* Helper for windows_xfer_partial that handles memory transfers.
2405 Arguments are like target_xfer_partial. */
2408 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2409 ULONGEST memaddr, LONGEST len)
2413 DWORD lasterror = 0;
2415 if (writebuf != NULL)
2417 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2418 plongest (len), core_addr_to_string (memaddr)));
2419 success = WriteProcessMemory (current_process_handle,
2420 (LPVOID) (uintptr_t) memaddr, writebuf,
2423 lasterror = GetLastError ();
2424 FlushInstructionCache (current_process_handle,
2425 (LPCVOID) (uintptr_t) memaddr, len);
2429 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2430 plongest (len), core_addr_to_string (memaddr)));
2431 success = ReadProcessMemory (current_process_handle,
2432 (LPCVOID) (uintptr_t) memaddr, readbuf,
2435 lasterror = GetLastError ();
2437 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2440 return success ? done : TARGET_XFER_E_IO;
2444 windows_kill_inferior (struct target_ops *ops)
2446 CHECK (TerminateProcess (current_process_handle, 0));
2450 if (!windows_continue (DBG_CONTINUE, -1))
2452 if (!WaitForDebugEvent (¤t_event, INFINITE))
2454 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2458 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2462 windows_prepare_to_store (struct regcache *regcache)
2464 /* Do nothing, since we can store individual regs. */
2468 windows_can_run (void)
2474 windows_close (void)
2476 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2477 ptid_get_pid (inferior_ptid)));
2480 /* Convert pid to printable format. */
2482 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2484 static char buf[80];
2486 if (ptid_get_tid (ptid) != 0)
2488 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2489 ptid_get_pid (ptid), ptid_get_tid (ptid));
2493 return normal_pid_to_str (ptid);
2497 windows_xfer_shared_libraries (struct target_ops *ops,
2498 enum target_object object, const char *annex,
2499 gdb_byte *readbuf, const gdb_byte *writebuf,
2500 ULONGEST offset, LONGEST len)
2502 struct obstack obstack;
2510 obstack_init (&obstack);
2511 obstack_grow_str (&obstack, "<library-list>\n");
2512 for (so = solib_start.next; so; so = so->next)
2513 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2514 (uintptr_t) so->lm_info->load_addr,
2515 target_gdbarch (), &obstack);
2516 obstack_grow_str0 (&obstack, "</library-list>\n");
2518 buf = obstack_finish (&obstack);
2519 len_avail = strlen (buf);
2520 if (offset >= len_avail)
2524 if (len > len_avail - offset)
2525 len = len_avail - offset;
2526 memcpy (readbuf, buf + offset, len);
2529 obstack_free (&obstack, NULL);
2534 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2535 const char *annex, gdb_byte *readbuf,
2536 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2540 case TARGET_OBJECT_MEMORY:
2541 return windows_xfer_memory (readbuf, writebuf, offset, len);
2543 case TARGET_OBJECT_LIBRARIES:
2544 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2545 writebuf, offset, len);
2548 if (ops->beneath != NULL)
2549 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2550 readbuf, writebuf, offset, len);
2555 /* Provide thread local base, i.e. Thread Information Block address.
2556 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2559 windows_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
2563 th = thread_rec (ptid_get_tid (ptid), 0);
2568 *addr = th->thread_local_base;
2574 windows_get_ada_task_ptid (long lwp, long thread)
2576 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2580 init_windows_ops (void)
2582 windows_ops.to_shortname = "child";
2583 windows_ops.to_longname = "Win32 child process";
2584 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2585 windows_ops.to_open = windows_open;
2586 windows_ops.to_close = windows_close;
2587 windows_ops.to_attach = windows_attach;
2588 windows_ops.to_attach_no_wait = 1;
2589 windows_ops.to_detach = windows_detach;
2590 windows_ops.to_resume = windows_resume;
2591 windows_ops.to_wait = windows_wait;
2592 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2593 windows_ops.to_store_registers = windows_store_inferior_registers;
2594 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2595 windows_ops.to_xfer_partial = windows_xfer_partial;
2596 windows_ops.to_files_info = windows_files_info;
2597 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2598 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2599 windows_ops.to_terminal_init = terminal_init_inferior;
2600 windows_ops.to_terminal_inferior = terminal_inferior;
2601 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2602 windows_ops.to_terminal_ours = terminal_ours;
2603 windows_ops.to_terminal_save_ours = terminal_save_ours;
2604 windows_ops.to_terminal_info = child_terminal_info;
2605 windows_ops.to_kill = windows_kill_inferior;
2606 windows_ops.to_create_inferior = windows_create_inferior;
2607 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2608 windows_ops.to_can_run = windows_can_run;
2609 windows_ops.to_thread_alive = windows_thread_alive;
2610 windows_ops.to_pid_to_str = windows_pid_to_str;
2611 windows_ops.to_stop = windows_stop;
2612 windows_ops.to_stratum = process_stratum;
2613 windows_ops.to_has_all_memory = default_child_has_all_memory;
2614 windows_ops.to_has_memory = default_child_has_memory;
2615 windows_ops.to_has_stack = default_child_has_stack;
2616 windows_ops.to_has_registers = default_child_has_registers;
2617 windows_ops.to_has_execution = default_child_has_execution;
2618 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2619 windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
2620 windows_ops.to_get_tib_address = windows_get_tib_address;
2622 i386_use_watchpoints (&windows_ops);
2624 i386_dr_low.set_control = cygwin_set_dr7;
2625 i386_dr_low.set_addr = cygwin_set_dr;
2626 i386_dr_low.get_addr = cygwin_get_dr;
2627 i386_dr_low.get_status = cygwin_get_dr6;
2628 i386_dr_low.get_control = cygwin_get_dr7;
2630 /* i386_dr_low.debug_register_length field is set by
2631 calling i386_set_debug_register_length function
2632 in processor windows specific native file. */
2634 windows_ops.to_magic = OPS_MAGIC;
2638 set_windows_aliases (char *argv0)
2640 add_info_alias ("dll", "sharedlibrary", 1);
2643 /* -Wmissing-prototypes */
2644 extern initialize_file_ftype _initialize_windows_nat;
2647 _initialize_windows_nat (void)
2649 struct cmd_list_element *c;
2651 init_windows_ops ();
2654 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2657 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2658 _("Load dll library symbols from FILE."));
2659 set_cmd_completer (c, filename_completer);
2661 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2663 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias, 1);
2665 add_com_alias ("assf", "dll-symbols", class_alias, 1);
2668 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2669 Set use of shell to start subprocess."), _("\
2670 Show use of shell to start subprocess."), NULL,
2672 NULL, /* FIXME: i18n: */
2673 &setlist, &showlist);
2675 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2676 &cygwin_exceptions, _("\
2677 Break when an exception is detected in the Cygwin DLL itself."), _("\
2678 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2680 NULL, /* FIXME: i18n: */
2681 &setlist, &showlist);
2684 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2685 Set creation of new console when creating child process."), _("\
2686 Show creation of new console when creating child process."), NULL,
2688 NULL, /* FIXME: i18n: */
2689 &setlist, &showlist);
2691 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2692 Set creation of new group when creating child process."), _("\
2693 Show creation of new group when creating child process."), NULL,
2695 NULL, /* FIXME: i18n: */
2696 &setlist, &showlist);
2698 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2699 Set whether to display execution in child process."), _("\
2700 Show whether to display execution in child process."), NULL,
2702 NULL, /* FIXME: i18n: */
2703 &setlist, &showlist);
2705 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2706 Set whether to display kernel events in child process."), _("\
2707 Show whether to display kernel events in child process."), NULL,
2709 NULL, /* FIXME: i18n: */
2710 &setlist, &showlist);
2712 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2713 Set whether to display memory accesses in child process."), _("\
2714 Show whether to display memory accesses in child process."), NULL,
2716 NULL, /* FIXME: i18n: */
2717 &setlist, &showlist);
2719 add_setshow_boolean_cmd ("debugexceptions", class_support,
2720 &debug_exceptions, _("\
2721 Set whether to display kernel exceptions in child process."), _("\
2722 Show whether to display kernel exceptions in child process."), NULL,
2724 NULL, /* FIXME: i18n: */
2725 &setlist, &showlist);
2727 init_w32_command_list ();
2729 add_cmd ("selector", class_info, display_selectors,
2730 _("Display selectors infos."),
2732 add_target (&windows_ops);
2733 deprecated_init_ui_hook = set_windows_aliases;
2736 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2738 /* Pass the address ADDR to the inferior in the I'th debug register.
2739 Here we just store the address in dr array, the registers will be
2740 actually set up when windows_continue is called. */
2742 cygwin_set_dr (int i, CORE_ADDR addr)
2745 internal_error (__FILE__, __LINE__,
2746 _("Invalid register %d in cygwin_set_dr.\n"), i);
2748 debug_registers_changed = 1;
2749 debug_registers_used = 1;
2752 /* Pass the value VAL to the inferior in the DR7 debug control
2753 register. Here we just store the address in D_REGS, the watchpoint
2754 will be actually set up in windows_wait. */
2756 cygwin_set_dr7 (unsigned long val)
2758 dr[7] = (CORE_ADDR) val;
2759 debug_registers_changed = 1;
2760 debug_registers_used = 1;
2763 /* Get the value of debug register I from the inferior. */
2766 cygwin_get_dr (int i)
2771 /* Get the value of the DR6 debug status register from the inferior.
2772 Here we just return the value stored in dr[6]
2773 by the last call to thread_rec for current_event.dwThreadId id. */
2774 static unsigned long
2775 cygwin_get_dr6 (void)
2777 return (unsigned long) dr[6];
2780 /* Get the value of the DR7 debug status register from the inferior.
2781 Here we just return the value stored in dr[7] by the last call to
2782 thread_rec for current_event.dwThreadId id. */
2784 static unsigned long
2785 cygwin_get_dr7 (void)
2787 return (unsigned long) dr[7];
2790 /* Determine if the thread referenced by "ptid" is alive
2791 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2792 it means that the thread has died. Otherwise it is assumed to be alive. */
2794 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2798 gdb_assert (ptid_get_tid (ptid) != 0);
2799 tid = ptid_get_tid (ptid);
2801 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
2805 /* -Wmissing-prototypes */
2806 extern initialize_file_ftype _initialize_check_for_gdb_ini;
2809 _initialize_check_for_gdb_ini (void)
2812 if (inhibit_gdbinit)
2815 homedir = getenv ("HOME");
2819 char *oldini = (char *) alloca (strlen (homedir) +
2820 sizeof ("/gdb.ini"));
2821 strcpy (oldini, homedir);
2822 p = strchr (oldini, '\0');
2823 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
2825 strcpy (p, "gdb.ini");
2826 if (access (oldini, 0) == 0)
2828 int len = strlen (oldini);
2829 char *newini = alloca (len + 1);
2831 xsnprintf (newini, len + 1, "%.*s.gdbinit",
2832 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2833 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2838 /* Define dummy functions which always return error for the rare cases where
2839 these functions could not be found. */
2841 bad_DebugActiveProcessStop (DWORD w)
2846 bad_DebugBreakProcess (HANDLE w)
2851 bad_DebugSetProcessKillOnExit (BOOL w)
2856 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2863 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2869 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2876 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2882 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2888 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
2894 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
2902 /* -Wmissing-prototypes */
2903 extern initialize_file_ftype _initialize_loadable;
2905 /* Load any functions which may not be available in ancient versions
2909 _initialize_loadable (void)
2913 hm = LoadLibrary ("kernel32.dll");
2916 DebugActiveProcessStop = (void *)
2917 GetProcAddress (hm, "DebugActiveProcessStop");
2918 DebugBreakProcess = (void *)
2919 GetProcAddress (hm, "DebugBreakProcess");
2920 DebugSetProcessKillOnExit = (void *)
2921 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2922 GetConsoleFontSize = (void *)
2923 GetProcAddress (hm, "GetConsoleFontSize");
2924 GetCurrentConsoleFont = (void *)
2925 GetProcAddress (hm, "GetCurrentConsoleFont");
2928 /* Set variables to dummy versions of these processes if the function
2929 wasn't found in kernel32.dll. */
2930 if (!DebugBreakProcess)
2931 DebugBreakProcess = bad_DebugBreakProcess;
2932 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2934 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2935 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2937 if (!GetConsoleFontSize)
2938 GetConsoleFontSize = bad_GetConsoleFontSize;
2939 if (!GetCurrentConsoleFont)
2940 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
2942 /* Load optional functions used for retrieving filename information
2943 associated with the currently debugged process or its dlls. */
2944 hm = LoadLibrary ("psapi.dll");
2947 EnumProcessModules = (void *)
2948 GetProcAddress (hm, "EnumProcessModules");
2949 GetModuleInformation = (void *)
2950 GetProcAddress (hm, "GetModuleInformation");
2951 GetModuleFileNameEx = (void *)
2952 GetProcAddress (hm, GetModuleFileNameEx_name);
2955 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2957 /* Set variables to dummy versions of these processes if the function
2958 wasn't found in psapi.dll. */
2959 EnumProcessModules = bad_EnumProcessModules;
2960 GetModuleInformation = bad_GetModuleInformation;
2961 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2962 /* This will probably fail on Windows 9x/Me. Let the user know
2963 that we're missing some functionality. */
2965 cannot automatically find executable file or library to read symbols.\n\
2966 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2969 hm = LoadLibrary ("advapi32.dll");
2972 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2973 LookupPrivilegeValueA = (void *)
2974 GetProcAddress (hm, "LookupPrivilegeValueA");
2975 AdjustTokenPrivileges = (void *)
2976 GetProcAddress (hm, "AdjustTokenPrivileges");
2977 /* Only need to set one of these since if OpenProcessToken fails nothing
2979 if (!OpenProcessToken || !LookupPrivilegeValueA
2980 || !AdjustTokenPrivileges)
2981 OpenProcessToken = bad_OpenProcessToken;