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 */
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++)
1768 wchar_t dll_name[__PMAX];
1771 char dll_name[__PMAX];
1774 if (GetModuleInformation (current_process_handle, hmodules[i],
1775 &mi, sizeof (mi)) == 0)
1777 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1778 dll_name, sizeof (dll_name)) == 0)
1781 wcstombs (name, dll_name, __PMAX);
1785 if (FILENAME_CMP (lbasename (name), "ntdll.dll") == 0)
1787 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1788 solib_end = solib_end->next;
1795 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1797 extern int stop_after_trap;
1799 struct inferior *inf;
1800 struct thread_info *tp;
1802 last_sig = GDB_SIGNAL_0;
1804 exception_count = 0;
1805 open_process_used = 0;
1806 debug_registers_changed = 0;
1807 debug_registers_used = 0;
1808 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1811 cygwin_load_start = cygwin_load_end = 0;
1813 current_event.dwProcessId = pid;
1814 memset (¤t_event, 0, sizeof (current_event));
1816 disable_breakpoints_in_shlibs ();
1817 windows_clear_solib ();
1818 clear_proceed_status ();
1819 init_wait_for_inferior ();
1821 inf = current_inferior ();
1822 inferior_appeared (inf, pid);
1823 inf->attach_flag = attaching;
1825 /* Make the new process the current inferior, so terminal handling
1826 can rely on it. When attaching, we don't know about any thread
1827 id here, but that's OK --- nothing should be referencing the
1828 current thread until we report an event out of windows_wait. */
1829 inferior_ptid = pid_to_ptid (pid);
1831 terminal_init_inferior_with_pgrp (pid);
1832 target_terminal_inferior ();
1834 windows_initialization_done = 0;
1835 inf->control.stop_soon = STOP_QUIETLY;
1838 stop_after_trap = 1;
1839 wait_for_inferior ();
1840 tp = inferior_thread ();
1841 if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP)
1842 resume (0, tp->suspend.stop_signal);
1847 /* FIXME: brobecker/2013-12-10: We should try another approach where
1848 we first ignore all DLL load/unload events up until this point,
1849 and then iterate over all modules to create the associated shared
1850 objects. This is a fairly significant change, however, and we are
1851 close to creating a release branch, so we are delaying it a bit,
1852 after the branch is created. */
1853 windows_ensure_ntdll_loaded ();
1855 windows_initialization_done = 1;
1856 inf->control.stop_soon = NO_STOP_QUIETLY;
1857 stop_after_trap = 0;
1861 /* Try to set or remove a user privilege to the current process. Return -1
1862 if that fails, the previous setting of that privilege otherwise.
1864 This code is copied from the Cygwin source code and rearranged to allow
1865 dynamically loading of the needed symbols from advapi32 which is only
1866 available on NT/2K/XP. */
1868 set_process_privilege (const char *privilege, BOOL enable)
1870 HANDLE token_hdl = NULL;
1872 TOKEN_PRIVILEGES new_priv, orig_priv;
1876 if (!OpenProcessToken (GetCurrentProcess (),
1877 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1881 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1884 new_priv.PrivilegeCount = 1;
1885 new_priv.Privileges[0].Luid = restore_priv;
1886 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1888 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1889 sizeof orig_priv, &orig_priv, &size))
1892 /* Disabled, otherwise every `attach' in an unprivileged user session
1893 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1894 windows_attach(). */
1895 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1896 be enabled. GetLastError () returns an correct error code, though. */
1897 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1901 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1905 CloseHandle (token_hdl);
1910 /* Attach to process PID, then initialize for debugging it. */
1912 windows_attach (struct target_ops *ops, char *args, int from_tty)
1917 pid = parse_pid_to_attach (args);
1919 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1921 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1922 printf_unfiltered ("This can cause attach to "
1923 "fail on Windows NT/2K/XP\n");
1926 windows_init_thread_list ();
1927 ok = DebugActiveProcess (pid);
1933 /* Try fall back to Cygwin pid. */
1934 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1937 ok = DebugActiveProcess (pid);
1942 error (_("Can't attach to process."));
1944 DebugSetProcessKillOnExit (FALSE);
1948 char *exec_file = (char *) get_exec_file (0);
1951 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1952 target_pid_to_str (pid_to_ptid (pid)));
1954 printf_unfiltered ("Attaching to %s\n",
1955 target_pid_to_str (pid_to_ptid (pid)));
1957 gdb_flush (gdb_stdout);
1960 do_initial_windows_stuff (ops, pid, 1);
1961 target_terminal_ours ();
1965 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1970 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1972 if (!DebugActiveProcessStop (current_event.dwProcessId))
1974 error (_("Can't detach process %u (error %u)"),
1975 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1978 DebugSetProcessKillOnExit (FALSE);
1980 if (detached && from_tty)
1982 char *exec_file = get_exec_file (0);
1985 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1986 (unsigned) current_event.dwProcessId);
1987 gdb_flush (gdb_stdout);
1990 i386_cleanup_dregs ();
1991 inferior_ptid = null_ptid;
1992 detach_inferior (current_event.dwProcessId);
1994 unpush_target (ops);
1998 windows_pid_to_exec_file (int pid)
2000 static char path[__PMAX];
2002 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2004 char procexe[sizeof ("/proc/4294967295/exe")];
2006 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
2007 nchars = readlink (procexe, path, sizeof(path));
2008 if (nchars > 0 && nchars < sizeof (path))
2010 path[nchars] = '\0'; /* Got it */
2015 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2016 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2017 if (!get_module_name (0, path))
2023 /* Print status information about what we're accessing. */
2026 windows_files_info (struct target_ops *ignore)
2028 struct inferior *inf = current_inferior ();
2030 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2031 inf->attach_flag ? "attached" : "child",
2032 target_pid_to_str (inferior_ptid));
2036 windows_open (char *arg, int from_tty)
2038 error (_("Use the \"run\" command to start a Unix child process."));
2041 /* Modify CreateProcess parameters for use of a new separate console.
2043 *FLAGS: DWORD parameter for general process creation flags.
2044 *SI: STARTUPINFO structure, for which the console window size and
2045 console buffer size is filled in if GDB is running in a console.
2046 to create the new console.
2047 The size of the used font is not available on all versions of
2048 Windows OS. Furthermore, the current font might not be the default
2049 font, but this is still better than before.
2050 If the windows and buffer sizes are computed,
2051 SI->DWFLAGS is changed so that this information is used
2052 by CreateProcess function. */
2055 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2057 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2058 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2060 if (hconsole != INVALID_HANDLE_VALUE)
2062 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2064 CONSOLE_FONT_INFO cfi;
2066 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2067 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2068 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2069 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2070 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2072 si->dwXSize *= font_size.X;
2076 si->dwYSize *= font_size.Y;
2079 si->dwXCountChars = sbinfo.dwSize.X;
2080 si->dwYCountChars = sbinfo.dwSize.Y;
2081 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2083 *flags |= CREATE_NEW_CONSOLE;
2087 /* Function called by qsort to sort environment strings. */
2090 envvar_cmp (const void *a, const void *b)
2092 const char **p = (const char **) a;
2093 const char **q = (const char **) b;
2094 return strcasecmp (*p, *q);
2100 clear_win32_environment (char **env)
2104 wchar_t *copy = NULL, *equalpos;
2106 for (i = 0; env[i] && *env[i]; i++)
2108 len = mbstowcs (NULL, env[i], 0) + 1;
2109 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2110 mbstowcs (copy, env[i], len);
2111 equalpos = wcschr (copy, L'=');
2114 SetEnvironmentVariableW (copy, NULL);
2120 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2121 EXEC_FILE is the file to run.
2122 ALLARGS is a string containing the arguments to the program.
2123 ENV is the environment vector to pass. Errors reported with error(). */
2126 windows_create_inferior (struct target_ops *ops, char *exec_file,
2127 char *allargs, char **in_env, int from_tty)
2131 cygwin_buf_t real_path[__PMAX];
2132 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2134 cygwin_buf_t *toexec;
2135 cygwin_buf_t *cygallargs;
2137 char **old_env = NULL;
2141 int ostdin, ostdout, ostderr;
2143 char real_path[__PMAX];
2144 char shell[__PMAX]; /* Path to shell */
2156 PROCESS_INFORMATION pi;
2159 const char *inferior_io_terminal = get_inferior_io_terminal ();
2162 error (_("No executable specified, use `target exec'."));
2164 memset (&si, 0, sizeof (si));
2165 si.cb = sizeof (si);
2168 flags |= CREATE_NEW_PROCESS_GROUP;
2171 windows_set_console_info (&si, &flags);
2176 flags |= DEBUG_ONLY_THIS_PROCESS;
2177 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2178 __PMAX * sizeof (cygwin_buf_t)) < 0)
2179 error (_("Error starting executable: %d"), errno);
2182 len = mbstowcs (NULL, allargs, 0) + 1;
2183 if (len == (size_t) -1)
2184 error (_("Error starting executable: %d"), errno);
2185 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2186 mbstowcs (cygallargs, allargs, len);
2188 cygallargs = allargs;
2193 sh = getenv ("SHELL");
2196 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2197 error (_("Error starting executable via shell: %d"), errno);
2199 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2200 + mbstowcs (NULL, allargs, 0) + 2;
2201 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2202 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2204 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2205 + strlen (allargs) + 2);
2206 cygallargs = (char *) alloca (len);
2207 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2210 flags |= DEBUG_PROCESS;
2214 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2215 * sizeof (wchar_t));
2216 wcscpy (args, toexec);
2217 wcscat (args, L" ");
2218 wcscat (args, cygallargs);
2220 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2221 strcpy (args, toexec);
2223 strcat (args, cygallargs);
2226 #ifdef CW_CVT_ENV_TO_WINENV
2227 /* First try to create a direct Win32 copy of the POSIX environment. */
2228 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2229 if (w32_env != (PWCHAR) -1)
2230 flags |= CREATE_UNICODE_ENVIRONMENT;
2232 /* If that fails, fall back to old method tweaking GDB's environment. */
2235 /* Reset all Win32 environment variables to avoid leftover on next run. */
2236 clear_win32_environment (environ);
2237 /* Prepare the environment vars for CreateProcess. */
2240 cygwin_internal (CW_SYNC_WINENV);
2244 if (!inferior_io_terminal)
2245 tty = ostdin = ostdout = ostderr = -1;
2248 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2251 print_sys_errmsg (inferior_io_terminal, errno);
2252 ostdin = ostdout = ostderr = -1;
2265 windows_init_thread_list ();
2266 ret = CreateProcess (0,
2267 args, /* command line */
2268 NULL, /* Security */
2270 TRUE, /* inherit handles */
2271 flags, /* start flags */
2272 w32_env, /* environment */
2273 NULL, /* current directory */
2277 /* Just free the Win32 environment, if it could be created. */
2281 /* Reset all environment variables to avoid leftover on next run. */
2282 clear_win32_environment (in_env);
2283 /* Restore normal GDB environment variables. */
2285 cygwin_internal (CW_SYNC_WINENV);
2300 /* Build the command line, a space-separated list of tokens where
2301 the first token is the name of the module to be executed.
2302 To avoid ambiguities introduced by spaces in the module name,
2304 args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
2305 args = alloca (args_len);
2306 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);
2308 flags |= DEBUG_ONLY_THIS_PROCESS;
2310 if (!inferior_io_terminal)
2311 tty = INVALID_HANDLE_VALUE;
2314 SECURITY_ATTRIBUTES sa;
2315 sa.nLength = sizeof(sa);
2316 sa.lpSecurityDescriptor = 0;
2317 sa.bInheritHandle = TRUE;
2318 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2319 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2320 if (tty == INVALID_HANDLE_VALUE)
2321 warning (_("Warning: Failed to open TTY %s, error %#x."),
2322 inferior_io_terminal, (unsigned) GetLastError ());
2326 si.hStdOutput = tty;
2328 si.dwFlags |= STARTF_USESTDHANDLES;
2332 /* CreateProcess takes the environment list as a null terminated set of
2333 strings (i.e. two nulls terminate the list). */
2335 /* Get total size for env strings. */
2336 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2337 envlen += strlen (in_env[i]) + 1;
2339 envsize = sizeof (in_env[0]) * (i + 1);
2340 env = (char **) alloca (envsize);
2341 memcpy (env, in_env, envsize);
2342 /* Windows programs expect the environment block to be sorted. */
2343 qsort (env, i, sizeof (char *), envvar_cmp);
2345 w32env = alloca (envlen + 1);
2347 /* Copy env strings into new buffer. */
2348 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2350 strcpy (temp, env[i]);
2351 temp += strlen (temp) + 1;
2354 /* Final nil string to terminate new env. */
2357 windows_init_thread_list ();
2358 ret = CreateProcessA (0,
2359 args, /* command line */
2360 NULL, /* Security */
2362 TRUE, /* inherit handles */
2363 flags, /* start flags */
2364 w32env, /* environment */
2365 NULL, /* current directory */
2368 if (tty != INVALID_HANDLE_VALUE)
2373 error (_("Error creating process %s, (error %u)."),
2374 exec_file, (unsigned) GetLastError ());
2376 CloseHandle (pi.hThread);
2377 CloseHandle (pi.hProcess);
2379 if (useshell && shell[0] != '\0')
2384 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2386 /* windows_continue (DBG_CONTINUE, -1); */
2390 windows_mourn_inferior (struct target_ops *ops)
2392 (void) windows_continue (DBG_CONTINUE, -1);
2393 i386_cleanup_dregs();
2394 if (open_process_used)
2396 CHECK (CloseHandle (current_process_handle));
2397 open_process_used = 0;
2399 unpush_target (ops);
2400 generic_mourn_inferior ();
2403 /* Send a SIGINT to the process group. This acts just like the user typed a
2404 ^C on the controlling terminal. */
2407 windows_stop (ptid_t ptid)
2409 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2410 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2411 registers_changed (); /* refresh register state */
2414 /* Helper for windows_xfer_partial that handles memory transfers.
2415 Arguments are like target_xfer_partial. */
2418 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2419 ULONGEST memaddr, LONGEST len)
2423 DWORD lasterror = 0;
2425 if (writebuf != NULL)
2427 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2428 plongest (len), core_addr_to_string (memaddr)));
2429 success = WriteProcessMemory (current_process_handle,
2430 (LPVOID) (uintptr_t) memaddr, writebuf,
2433 lasterror = GetLastError ();
2434 FlushInstructionCache (current_process_handle,
2435 (LPCVOID) (uintptr_t) memaddr, len);
2439 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2440 plongest (len), core_addr_to_string (memaddr)));
2441 success = ReadProcessMemory (current_process_handle,
2442 (LPCVOID) (uintptr_t) memaddr, readbuf,
2445 lasterror = GetLastError ();
2447 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2450 return success ? done : TARGET_XFER_E_IO;
2454 windows_kill_inferior (struct target_ops *ops)
2456 CHECK (TerminateProcess (current_process_handle, 0));
2460 if (!windows_continue (DBG_CONTINUE, -1))
2462 if (!WaitForDebugEvent (¤t_event, INFINITE))
2464 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2468 target_mourn_inferior (); /* Or just windows_mourn_inferior? */
2472 windows_prepare_to_store (struct regcache *regcache)
2474 /* Do nothing, since we can store individual regs. */
2478 windows_can_run (void)
2484 windows_close (void)
2486 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2487 ptid_get_pid (inferior_ptid)));
2490 /* Convert pid to printable format. */
2492 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2494 static char buf[80];
2496 if (ptid_get_tid (ptid) != 0)
2498 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2499 ptid_get_pid (ptid), ptid_get_tid (ptid));
2503 return normal_pid_to_str (ptid);
2507 windows_xfer_shared_libraries (struct target_ops *ops,
2508 enum target_object object, const char *annex,
2509 gdb_byte *readbuf, const gdb_byte *writebuf,
2510 ULONGEST offset, LONGEST len)
2512 struct obstack obstack;
2520 obstack_init (&obstack);
2521 obstack_grow_str (&obstack, "<library-list>\n");
2522 for (so = solib_start.next; so; so = so->next)
2523 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2524 (uintptr_t) so->lm_info->load_addr,
2525 target_gdbarch (), &obstack);
2526 obstack_grow_str0 (&obstack, "</library-list>\n");
2528 buf = obstack_finish (&obstack);
2529 len_avail = strlen (buf);
2530 if (offset >= len_avail)
2534 if (len > len_avail - offset)
2535 len = len_avail - offset;
2536 memcpy (readbuf, buf + offset, len);
2539 obstack_free (&obstack, NULL);
2544 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2545 const char *annex, gdb_byte *readbuf,
2546 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2550 case TARGET_OBJECT_MEMORY:
2551 return windows_xfer_memory (readbuf, writebuf, offset, len);
2553 case TARGET_OBJECT_LIBRARIES:
2554 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2555 writebuf, offset, len);
2558 if (ops->beneath != NULL)
2559 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2560 readbuf, writebuf, offset, len);
2565 /* Provide thread local base, i.e. Thread Information Block address.
2566 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2569 windows_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
2573 th = thread_rec (ptid_get_tid (ptid), 0);
2578 *addr = th->thread_local_base;
2584 windows_get_ada_task_ptid (long lwp, long thread)
2586 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2590 init_windows_ops (void)
2592 windows_ops.to_shortname = "child";
2593 windows_ops.to_longname = "Win32 child process";
2594 windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2595 windows_ops.to_open = windows_open;
2596 windows_ops.to_close = windows_close;
2597 windows_ops.to_attach = windows_attach;
2598 windows_ops.to_attach_no_wait = 1;
2599 windows_ops.to_detach = windows_detach;
2600 windows_ops.to_resume = windows_resume;
2601 windows_ops.to_wait = windows_wait;
2602 windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2603 windows_ops.to_store_registers = windows_store_inferior_registers;
2604 windows_ops.to_prepare_to_store = windows_prepare_to_store;
2605 windows_ops.to_xfer_partial = windows_xfer_partial;
2606 windows_ops.to_files_info = windows_files_info;
2607 windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2608 windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2609 windows_ops.to_terminal_init = terminal_init_inferior;
2610 windows_ops.to_terminal_inferior = terminal_inferior;
2611 windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2612 windows_ops.to_terminal_ours = terminal_ours;
2613 windows_ops.to_terminal_save_ours = terminal_save_ours;
2614 windows_ops.to_terminal_info = child_terminal_info;
2615 windows_ops.to_kill = windows_kill_inferior;
2616 windows_ops.to_create_inferior = windows_create_inferior;
2617 windows_ops.to_mourn_inferior = windows_mourn_inferior;
2618 windows_ops.to_can_run = windows_can_run;
2619 windows_ops.to_thread_alive = windows_thread_alive;
2620 windows_ops.to_pid_to_str = windows_pid_to_str;
2621 windows_ops.to_stop = windows_stop;
2622 windows_ops.to_stratum = process_stratum;
2623 windows_ops.to_has_all_memory = default_child_has_all_memory;
2624 windows_ops.to_has_memory = default_child_has_memory;
2625 windows_ops.to_has_stack = default_child_has_stack;
2626 windows_ops.to_has_registers = default_child_has_registers;
2627 windows_ops.to_has_execution = default_child_has_execution;
2628 windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2629 windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
2630 windows_ops.to_get_tib_address = windows_get_tib_address;
2632 i386_use_watchpoints (&windows_ops);
2634 i386_dr_low.set_control = cygwin_set_dr7;
2635 i386_dr_low.set_addr = cygwin_set_dr;
2636 i386_dr_low.get_addr = cygwin_get_dr;
2637 i386_dr_low.get_status = cygwin_get_dr6;
2638 i386_dr_low.get_control = cygwin_get_dr7;
2640 /* i386_dr_low.debug_register_length field is set by
2641 calling i386_set_debug_register_length function
2642 in processor windows specific native file. */
2644 windows_ops.to_magic = OPS_MAGIC;
2648 set_windows_aliases (char *argv0)
2650 add_info_alias ("dll", "sharedlibrary", 1);
2653 /* -Wmissing-prototypes */
2654 extern initialize_file_ftype _initialize_windows_nat;
2657 _initialize_windows_nat (void)
2659 struct cmd_list_element *c;
2661 init_windows_ops ();
2664 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2667 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2668 _("Load dll library symbols from FILE."));
2669 set_cmd_completer (c, filename_completer);
2671 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2673 add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias, 1);
2675 add_com_alias ("assf", "dll-symbols", class_alias, 1);
2678 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2679 Set use of shell to start subprocess."), _("\
2680 Show use of shell to start subprocess."), NULL,
2682 NULL, /* FIXME: i18n: */
2683 &setlist, &showlist);
2685 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2686 &cygwin_exceptions, _("\
2687 Break when an exception is detected in the Cygwin DLL itself."), _("\
2688 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2690 NULL, /* FIXME: i18n: */
2691 &setlist, &showlist);
2694 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2695 Set creation of new console when creating child process."), _("\
2696 Show creation of new console when creating child process."), NULL,
2698 NULL, /* FIXME: i18n: */
2699 &setlist, &showlist);
2701 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2702 Set creation of new group when creating child process."), _("\
2703 Show creation of new group when creating child process."), NULL,
2705 NULL, /* FIXME: i18n: */
2706 &setlist, &showlist);
2708 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2709 Set whether to display execution in child process."), _("\
2710 Show whether to display execution in child process."), NULL,
2712 NULL, /* FIXME: i18n: */
2713 &setlist, &showlist);
2715 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2716 Set whether to display kernel events in child process."), _("\
2717 Show whether to display kernel events in child process."), NULL,
2719 NULL, /* FIXME: i18n: */
2720 &setlist, &showlist);
2722 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2723 Set whether to display memory accesses in child process."), _("\
2724 Show whether to display memory accesses in child process."), NULL,
2726 NULL, /* FIXME: i18n: */
2727 &setlist, &showlist);
2729 add_setshow_boolean_cmd ("debugexceptions", class_support,
2730 &debug_exceptions, _("\
2731 Set whether to display kernel exceptions in child process."), _("\
2732 Show whether to display kernel exceptions in child process."), NULL,
2734 NULL, /* FIXME: i18n: */
2735 &setlist, &showlist);
2737 init_w32_command_list ();
2739 add_cmd ("selector", class_info, display_selectors,
2740 _("Display selectors infos."),
2742 add_target (&windows_ops);
2743 deprecated_init_ui_hook = set_windows_aliases;
2746 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2748 /* Pass the address ADDR to the inferior in the I'th debug register.
2749 Here we just store the address in dr array, the registers will be
2750 actually set up when windows_continue is called. */
2752 cygwin_set_dr (int i, CORE_ADDR addr)
2755 internal_error (__FILE__, __LINE__,
2756 _("Invalid register %d in cygwin_set_dr.\n"), i);
2758 debug_registers_changed = 1;
2759 debug_registers_used = 1;
2762 /* Pass the value VAL to the inferior in the DR7 debug control
2763 register. Here we just store the address in D_REGS, the watchpoint
2764 will be actually set up in windows_wait. */
2766 cygwin_set_dr7 (unsigned long val)
2768 dr[7] = (CORE_ADDR) val;
2769 debug_registers_changed = 1;
2770 debug_registers_used = 1;
2773 /* Get the value of debug register I from the inferior. */
2776 cygwin_get_dr (int i)
2781 /* Get the value of the DR6 debug status register from the inferior.
2782 Here we just return the value stored in dr[6]
2783 by the last call to thread_rec for current_event.dwThreadId id. */
2784 static unsigned long
2785 cygwin_get_dr6 (void)
2787 return (unsigned long) dr[6];
2790 /* Get the value of the DR7 debug status register from the inferior.
2791 Here we just return the value stored in dr[7] by the last call to
2792 thread_rec for current_event.dwThreadId id. */
2794 static unsigned long
2795 cygwin_get_dr7 (void)
2797 return (unsigned long) dr[7];
2800 /* Determine if the thread referenced by "ptid" is alive
2801 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2802 it means that the thread has died. Otherwise it is assumed to be alive. */
2804 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2808 gdb_assert (ptid_get_tid (ptid) != 0);
2809 tid = ptid_get_tid (ptid);
2811 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
2815 /* -Wmissing-prototypes */
2816 extern initialize_file_ftype _initialize_check_for_gdb_ini;
2819 _initialize_check_for_gdb_ini (void)
2822 if (inhibit_gdbinit)
2825 homedir = getenv ("HOME");
2829 char *oldini = (char *) alloca (strlen (homedir) +
2830 sizeof ("/gdb.ini"));
2831 strcpy (oldini, homedir);
2832 p = strchr (oldini, '\0');
2833 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
2835 strcpy (p, "gdb.ini");
2836 if (access (oldini, 0) == 0)
2838 int len = strlen (oldini);
2839 char *newini = alloca (len + 1);
2841 xsnprintf (newini, len + 1, "%.*s.gdbinit",
2842 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2843 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2848 /* Define dummy functions which always return error for the rare cases where
2849 these functions could not be found. */
2851 bad_DebugActiveProcessStop (DWORD w)
2856 bad_DebugBreakProcess (HANDLE w)
2861 bad_DebugSetProcessKillOnExit (BOOL w)
2866 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
2873 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
2879 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
2886 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
2892 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
2898 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
2904 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
2912 /* -Wmissing-prototypes */
2913 extern initialize_file_ftype _initialize_loadable;
2915 /* Load any functions which may not be available in ancient versions
2919 _initialize_loadable (void)
2923 hm = LoadLibrary ("kernel32.dll");
2926 DebugActiveProcessStop = (void *)
2927 GetProcAddress (hm, "DebugActiveProcessStop");
2928 DebugBreakProcess = (void *)
2929 GetProcAddress (hm, "DebugBreakProcess");
2930 DebugSetProcessKillOnExit = (void *)
2931 GetProcAddress (hm, "DebugSetProcessKillOnExit");
2932 GetConsoleFontSize = (void *)
2933 GetProcAddress (hm, "GetConsoleFontSize");
2934 GetCurrentConsoleFont = (void *)
2935 GetProcAddress (hm, "GetCurrentConsoleFont");
2938 /* Set variables to dummy versions of these processes if the function
2939 wasn't found in kernel32.dll. */
2940 if (!DebugBreakProcess)
2941 DebugBreakProcess = bad_DebugBreakProcess;
2942 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
2944 DebugActiveProcessStop = bad_DebugActiveProcessStop;
2945 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
2947 if (!GetConsoleFontSize)
2948 GetConsoleFontSize = bad_GetConsoleFontSize;
2949 if (!GetCurrentConsoleFont)
2950 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
2952 /* Load optional functions used for retrieving filename information
2953 associated with the currently debugged process or its dlls. */
2954 hm = LoadLibrary ("psapi.dll");
2957 EnumProcessModules = (void *)
2958 GetProcAddress (hm, "EnumProcessModules");
2959 GetModuleInformation = (void *)
2960 GetProcAddress (hm, "GetModuleInformation");
2961 GetModuleFileNameEx = (void *)
2962 GetProcAddress (hm, GetModuleFileNameEx_name);
2965 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
2967 /* Set variables to dummy versions of these processes if the function
2968 wasn't found in psapi.dll. */
2969 EnumProcessModules = bad_EnumProcessModules;
2970 GetModuleInformation = bad_GetModuleInformation;
2971 GetModuleFileNameEx = bad_GetModuleFileNameEx;
2972 /* This will probably fail on Windows 9x/Me. Let the user know
2973 that we're missing some functionality. */
2975 cannot automatically find executable file or library to read symbols.\n\
2976 Use \"file\" or \"dll\" command to load executable/libraries directly."));
2979 hm = LoadLibrary ("advapi32.dll");
2982 OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
2983 LookupPrivilegeValueA = (void *)
2984 GetProcAddress (hm, "LookupPrivilegeValueA");
2985 AdjustTokenPrivileges = (void *)
2986 GetProcAddress (hm, "AdjustTokenPrivileges");
2987 /* Only need to set one of these since if OpenProcessToken fails nothing
2989 if (!OpenProcessToken || !LookupPrivilegeValueA
2990 || !AdjustTokenPrivileges)
2991 OpenProcessToken = bad_OpenProcessToken;