1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2016 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 */
31 #include "completer.h"
35 #include <sys/types.h>
42 #include <sys/cygwin.h>
43 #include <cygwin/version.h>
47 #include "filenames.h"
51 #include "gdb_obstack.h"
52 #include "gdbthread.h"
58 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "windows-tdep.h"
65 #include "windows-nat.h"
67 #include "complaints.h"
68 #include "inf-child.h"
70 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
71 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
72 #define DebugBreakProcess dyn_DebugBreakProcess
73 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
74 #define EnumProcessModules dyn_EnumProcessModules
75 #define GetModuleInformation dyn_GetModuleInformation
76 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
77 #define OpenProcessToken dyn_OpenProcessToken
78 #define GetConsoleFontSize dyn_GetConsoleFontSize
79 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
81 typedef BOOL WINAPI (AdjustTokenPrivileges_ftype) (HANDLE, BOOL,
83 DWORD, PTOKEN_PRIVILEGES,
85 static AdjustTokenPrivileges_ftype *AdjustTokenPrivileges;
87 typedef BOOL WINAPI (DebugActiveProcessStop_ftype) (DWORD);
88 static DebugActiveProcessStop_ftype *DebugActiveProcessStop;
90 typedef BOOL WINAPI (DebugBreakProcess_ftype) (HANDLE);
91 static DebugBreakProcess_ftype *DebugBreakProcess;
93 typedef BOOL WINAPI (DebugSetProcessKillOnExit_ftype) (BOOL);
94 static DebugSetProcessKillOnExit_ftype *DebugSetProcessKillOnExit;
96 typedef BOOL WINAPI (EnumProcessModules_ftype) (HANDLE, HMODULE *, DWORD,
98 static EnumProcessModules_ftype *EnumProcessModules;
100 typedef BOOL WINAPI (GetModuleInformation_ftype) (HANDLE, HMODULE,
101 LPMODULEINFO, DWORD);
102 static GetModuleInformation_ftype *GetModuleInformation;
104 typedef BOOL WINAPI (LookupPrivilegeValueA_ftype) (LPCSTR, LPCSTR, PLUID);
105 static LookupPrivilegeValueA_ftype *LookupPrivilegeValueA;
107 typedef BOOL WINAPI (OpenProcessToken_ftype) (HANDLE, DWORD, PHANDLE);
108 static OpenProcessToken_ftype *OpenProcessToken;
110 typedef BOOL WINAPI (GetCurrentConsoleFont_ftype) (HANDLE, BOOL,
111 CONSOLE_FONT_INFO *);
112 static GetCurrentConsoleFont_ftype *GetCurrentConsoleFont;
114 typedef COORD WINAPI (GetConsoleFontSize_ftype) (HANDLE, DWORD);
115 static GetConsoleFontSize_ftype *GetConsoleFontSize;
119 #undef GetModuleFileNameEx
122 # define __PMAX (MAX_PATH + 1)
123 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, LPSTR, DWORD);
124 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
125 # define STARTUPINFO STARTUPINFOA
126 # define CreateProcess CreateProcessA
127 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
128 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
130 # define __PMAX PATH_MAX
131 /* The starting and ending address of the cygwin1.dll text segment. */
132 static CORE_ADDR cygwin_load_start;
133 static CORE_ADDR cygwin_load_end;
135 typedef wchar_t cygwin_buf_t;
136 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE,
138 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
139 # define STARTUPINFO STARTUPINFOW
140 # define CreateProcess CreateProcessW
141 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
142 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
145 static int have_saved_context; /* True if we've saved context from a
147 static CONTEXT saved_context; /* Containes the saved context from a
150 /* If we're not using the old Cygwin header file set, define the
151 following which never should have been in the generic Win32 API
152 headers in the first place since they were our own invention... */
153 #ifndef _GNU_H_WINDOWS_H
156 FLAG_TRACE_BIT = 0x100,
160 #ifndef CONTEXT_EXTENDED_REGISTERS
161 /* This macro is only defined on ia32. It only makes sense on this target,
162 so define it as zero if not already defined. */
163 #define CONTEXT_EXTENDED_REGISTERS 0
166 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
167 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
168 | CONTEXT_EXTENDED_REGISTERS
170 static uintptr_t dr[8];
171 static int debug_registers_changed;
172 static int debug_registers_used;
174 static int windows_initialization_done;
175 #define DR6_CLEAR_VALUE 0xffff0ff0
177 /* The exception thrown by a program to tell the debugger the name of
178 a thread. The exception record contains an ID of a thread and a
179 name to give it. This exception has no documented name, but MSDN
180 dubs it "MS_VC_EXCEPTION" in one code example. */
181 #define MS_VC_EXCEPTION 0x406d1388
185 HANDLE_EXCEPTION_UNHANDLED = 0,
186 HANDLE_EXCEPTION_HANDLED,
187 HANDLE_EXCEPTION_IGNORED
188 } handle_exception_result;
190 /* The string sent by cygwin when it processes a signal.
191 FIXME: This should be in a cygwin include file. */
192 #ifndef _CYGWIN_SIGNAL_STRING
193 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
196 #define CHECK(x) check (x, __FILE__,__LINE__)
197 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
198 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
199 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
200 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
202 static void windows_interrupt (struct target_ops *self, ptid_t);
203 static int windows_thread_alive (struct target_ops *, ptid_t);
204 static void windows_kill_inferior (struct target_ops *);
206 static void cygwin_set_dr (int i, CORE_ADDR addr);
207 static void cygwin_set_dr7 (unsigned long val);
208 static CORE_ADDR cygwin_get_dr (int i);
209 static unsigned long cygwin_get_dr6 (void);
210 static unsigned long cygwin_get_dr7 (void);
212 static enum gdb_signal last_sig = GDB_SIGNAL_0;
213 /* Set if a signal was received from the debugged process. */
215 /* Thread information structure used to track information that is
216 not available in gdb's thread structure. */
217 typedef struct windows_thread_info_struct
219 struct windows_thread_info_struct *next;
222 CORE_ADDR thread_local_base;
231 static windows_thread_info thread_head;
233 /* The process and thread handles for the above context. */
235 static DEBUG_EVENT current_event; /* The current debug event from
237 static HANDLE current_process_handle; /* Currently executing process */
238 static windows_thread_info *current_thread; /* Info on currently selected thread */
239 static DWORD main_thread_id; /* Thread ID of the main thread */
241 /* Counts of things. */
242 static int exception_count = 0;
243 static int event_count = 0;
244 static int saw_create;
245 static int open_process_used = 0;
248 static int new_console = 0;
250 static int cygwin_exceptions = 0;
252 static int new_group = 1;
253 static int debug_exec = 0; /* show execution */
254 static int debug_events = 0; /* show events from kernel */
255 static int debug_memory = 0; /* show target memory accesses */
256 static int debug_exceptions = 0; /* show target exceptions */
257 static int useshell = 0; /* use shell for subprocesses */
259 /* This vector maps GDB's idea of a register's number into an offset
260 in the windows exception context vector.
262 It also contains the bit mask needed to load the register in question.
264 The contents of this table can only be computed by the units
265 that provide CPU-specific support for Windows native debugging.
266 These units should set the table by calling
267 windows_set_context_register_offsets.
269 One day we could read a reg, we could inspect the context we
270 already have loaded, if it doesn't have the bit set that we need,
271 we read that set of registers in using GetThreadContext. If the
272 context already contains what we need, we just unpack it. Then to
273 write a register, first we have to ensure that the context contains
274 the other regs of the group, and then we copy the info in and set
277 static const int *mappings;
279 /* The function to use in order to determine whether a register is
280 a segment register or not. */
281 static segment_register_p_ftype *segment_register_p;
283 /* This vector maps the target's idea of an exception (extracted
284 from the DEBUG_EVENT structure) to GDB's idea. */
286 struct xlate_exception
292 static const struct xlate_exception
295 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
296 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
297 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
298 {DBG_CONTROL_C, GDB_SIGNAL_INT},
299 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
300 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
301 {-1, GDB_SIGNAL_UNKNOWN}};
303 /* Set the MAPPINGS static global to OFFSETS.
304 See the description of MAPPINGS for more details. */
307 windows_set_context_register_offsets (const int *offsets)
312 /* See windows-nat.h. */
315 windows_set_segment_register_p (segment_register_p_ftype *fun)
317 segment_register_p = fun;
321 check (BOOL ok, const char *file, int line)
324 printf_filtered ("error return %s:%d was %u\n", file, line,
325 (unsigned) GetLastError ());
328 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
329 then also retrieve the context for this thread. If GET_CONTEXT is
330 negative, then don't suspend the thread. */
331 static windows_thread_info *
332 thread_rec (DWORD id, int get_context)
334 windows_thread_info *th;
336 for (th = &thread_head; (th = th->next) != NULL;)
339 if (!th->suspended && get_context)
341 if (get_context > 0 && id != current_event.dwThreadId)
343 if (SuspendThread (th->h) == (DWORD) -1)
345 DWORD err = GetLastError ();
347 /* We get Access Denied (5) when trying to suspend
348 threads that Windows started on behalf of the
349 debuggee, usually when those threads are just
351 We can get Invalid Handle (6) if the main thread
353 if (err != ERROR_INVALID_HANDLE
354 && err != ERROR_ACCESS_DENIED)
355 warning (_("SuspendThread (tid=0x%x) failed."
357 (unsigned) id, (unsigned) err);
363 else if (get_context < 0)
365 th->reload_context = 1;
373 /* Add a thread to the thread list. */
374 static windows_thread_info *
375 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
377 windows_thread_info *th;
380 gdb_assert (ptid_get_tid (ptid) != 0);
382 id = ptid_get_tid (ptid);
384 if ((th = thread_rec (id, FALSE)))
387 th = XCNEW (windows_thread_info);
390 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
391 th->next = thread_head.next;
392 thread_head.next = th;
394 /* Set the debug registers for the new thread if they are used. */
395 if (debug_registers_used)
397 /* Only change the value of the debug registers. */
398 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
399 CHECK (GetThreadContext (th->h, &th->context));
400 th->context.Dr0 = dr[0];
401 th->context.Dr1 = dr[1];
402 th->context.Dr2 = dr[2];
403 th->context.Dr3 = dr[3];
404 th->context.Dr6 = DR6_CLEAR_VALUE;
405 th->context.Dr7 = dr[7];
406 CHECK (SetThreadContext (th->h, &th->context));
407 th->context.ContextFlags = 0;
412 /* Clear out any old thread list and reinitialize it to a
415 windows_init_thread_list (void)
417 windows_thread_info *th = &thread_head;
419 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
421 while (th->next != NULL)
423 windows_thread_info *here = th->next;
424 th->next = here->next;
427 thread_head.next = NULL;
430 /* Delete a thread from the list of threads. */
432 windows_delete_thread (ptid_t ptid, DWORD exit_code)
434 windows_thread_info *th;
437 gdb_assert (ptid_get_tid (ptid) != 0);
439 id = ptid_get_tid (ptid);
442 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
443 else if (print_thread_events && id != main_thread_id)
444 printf_unfiltered (_("[%s exited with code %u]\n"),
445 target_pid_to_str (ptid), (unsigned) exit_code);
446 delete_thread (ptid);
448 for (th = &thread_head;
449 th->next != NULL && th->next->id != id;
453 if (th->next != NULL)
455 windows_thread_info *here = th->next;
456 th->next = here->next;
463 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
465 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
466 struct gdbarch *gdbarch = get_regcache_arch (regcache);
467 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
471 return; /* Windows sometimes uses a non-existent thread id in its
474 if (current_thread->reload_context)
477 if (have_saved_context)
479 /* Lie about where the program actually is stopped since
480 cygwin has informed us that we should consider the signal
481 to have occurred at another location which is stored in
483 memcpy (¤t_thread->context, &saved_context,
484 __COPY_CONTEXT_SIZE);
485 have_saved_context = 0;
490 windows_thread_info *th = current_thread;
491 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
492 CHECK (GetThreadContext (th->h, &th->context));
493 /* Copy dr values from that thread.
494 But only if there were not modified since last stop.
496 if (!debug_registers_changed)
498 dr[0] = th->context.Dr0;
499 dr[1] = th->context.Dr1;
500 dr[2] = th->context.Dr2;
501 dr[3] = th->context.Dr3;
502 dr[6] = th->context.Dr6;
503 dr[7] = th->context.Dr7;
506 current_thread->reload_context = 0;
509 if (r == I387_FISEG_REGNUM (tdep))
511 l = *((long *) context_offset) & 0xffff;
512 regcache_raw_supply (regcache, r, (char *) &l);
514 else if (r == I387_FOP_REGNUM (tdep))
516 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
517 regcache_raw_supply (regcache, r, (char *) &l);
519 else if (segment_register_p (r))
521 /* GDB treats segment registers as 32bit registers, but they are
522 in fact only 16 bits long. Make sure we do not read extra
523 bits from our source buffer. */
524 l = *((long *) context_offset) & 0xffff;
525 regcache_raw_supply (regcache, r, (char *) &l);
528 regcache_raw_supply (regcache, r, context_offset);
531 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
532 do_windows_fetch_inferior_registers (regcache, r);
537 windows_fetch_inferior_registers (struct target_ops *ops,
538 struct regcache *regcache, int r)
540 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
541 /* Check if current_thread exists. Windows sometimes uses a non-existent
542 thread id in its events. */
544 do_windows_fetch_inferior_registers (regcache, r);
548 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
551 /* Windows sometimes uses a non-existent thread id in its events. */;
553 regcache_raw_collect (regcache, r,
554 ((char *) ¤t_thread->context) + mappings[r]);
557 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
558 do_windows_store_inferior_registers (regcache, r);
562 /* Store a new register value into the current thread context. */
564 windows_store_inferior_registers (struct target_ops *ops,
565 struct regcache *regcache, int r)
567 current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
568 /* Check if current_thread exists. Windows sometimes uses a non-existent
569 thread id in its events. */
571 do_windows_store_inferior_registers (regcache, r);
574 /* Encapsulate the information required in a call to
575 symbol_file_add_args. */
576 struct safe_symbol_file_add_args
580 struct section_addr_info *addrs;
583 struct ui_file *err, *out;
587 /* Maintain a linked list of "so" information. */
593 static struct so_list solib_start, *solib_end;
595 static struct so_list *
596 windows_make_so (const char *name, LPVOID load_addr)
603 WIN32_FIND_DATA w32_fd;
604 HANDLE h = FindFirstFile(name, &w32_fd);
606 if (h == INVALID_HANDLE_VALUE)
612 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
614 p = strrchr (buf, '\\');
617 SetCurrentDirectory (buf);
618 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
619 SetCurrentDirectory (cwd);
622 if (strcasecmp (buf, "ntdll.dll") == 0)
624 GetSystemDirectory (buf, sizeof (buf));
625 strcat (buf, "\\ntdll.dll");
628 cygwin_buf_t buf[__PMAX];
631 if (access (name, F_OK) != 0)
633 if (strcasecmp (name, "ntdll.dll") == 0)
636 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
637 wcscat (buf, L"\\ntdll.dll");
641 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
642 strcat (buf, "\\ntdll.dll");
647 so = XCNEW (struct so_list);
648 so->lm_info = XNEW (struct lm_info);
649 so->lm_info->load_addr = load_addr;
650 strcpy (so->so_original_name, name);
652 strcpy (so->so_name, buf);
655 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
656 SO_NAME_MAX_PATH_SIZE);
659 char *rname = realpath (name, NULL);
660 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
662 strcpy (so->so_name, rname);
666 error (_("dll path too long"));
668 /* Record cygwin1.dll .text start/end. */
669 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
670 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
673 asection *text = NULL;
676 abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);
681 if (bfd_check_format (abfd, bfd_object))
682 text = bfd_get_section_by_name (abfd, ".text");
686 gdb_bfd_unref (abfd);
690 /* The symbols in a dll are offset by 0x1000, which is the
691 offset from 0 of the first byte in an image - because of the
692 file header and the section alignment. */
693 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
695 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
697 gdb_bfd_unref (abfd);
705 get_image_name (HANDLE h, void *address, int unicode)
708 static char buf[__PMAX];
710 static char buf[(2 * __PMAX) + 1];
712 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
718 /* Attempt to read the name of the dll that was detected.
719 This is documented to work only when actively debugging
720 a program. It will not work for attached processes. */
724 /* See if we could read the address of a string, and that the
725 address isn't null. */
726 if (!ReadProcessMemory (h, address, &address_ptr,
727 sizeof (address_ptr), &done)
728 || done != sizeof (address_ptr) || !address_ptr)
731 /* Find the length of the string. */
732 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
733 && (b[0] != 0 || b[size - 1] != 0) && done == size)
737 ReadProcessMemory (h, address_ptr, buf, len, &done);
740 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
741 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
744 wcstombs (buf, unicode_address, __PMAX);
746 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
754 /* Handle a DLL load event, and return 1.
756 This function assumes that this event did not occur during inferior
757 initialization, where their event info may be incomplete (see
758 do_initial_windows_stuff and windows_add_all_dlls for more info
759 on how we handle DLL loading during that phase). */
762 handle_load_dll (void *dummy)
764 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
767 /* Try getting the DLL name via the lpImageName field of the event.
768 Note that Microsoft documents this fields as strictly optional,
769 in the sense that it might be NULL. And the first DLL event in
770 particular is explicitly documented as "likely not pass[ed]"
771 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
772 dll_name = get_image_name (current_process_handle,
773 event->lpImageName, event->fUnicode);
777 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
778 solib_end = solib_end->next;
780 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
781 host_address_to_string (solib_end->lm_info->load_addr)));
787 windows_free_so (struct so_list *so)
794 /* Handle a DLL unload event.
795 Return 1 if successful, or zero otherwise.
797 This function assumes that this event did not occur during inferior
798 initialization, where their event info may be incomplete (see
799 do_initial_windows_stuff and windows_add_all_dlls for more info
800 on how we handle DLL loading during that phase). */
803 handle_unload_dll (void *dummy)
805 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
808 for (so = &solib_start; so->next != NULL; so = so->next)
809 if (so->next->lm_info->load_addr == lpBaseOfDll)
811 struct so_list *sodel = so->next;
813 so->next = sodel->next;
816 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
818 windows_free_so (sodel);
822 /* We did not find any DLL that was previously loaded at this address,
823 so register a complaint. We do not report an error, because we have
824 observed that this may be happening under some circumstances. For
825 instance, running 32bit applications on x64 Windows causes us to receive
826 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
827 events are apparently caused by the WOW layer, the interface between
828 32bit and 64bit worlds). */
829 complaint (&symfile_complaints, _("dll starting at %s not found."),
830 host_address_to_string (lpBaseOfDll));
835 /* Clear list of loaded DLLs. */
837 windows_clear_solib (void)
839 solib_start.next = NULL;
840 solib_end = &solib_start;
844 signal_event_command (char *args, int from_tty)
846 uintptr_t event_id = 0;
847 char *endargs = NULL;
850 error (_("signal-event requires an argument (integer event id)"));
852 event_id = strtoumax (args, &endargs, 10);
854 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) ||
855 ((HANDLE) event_id == INVALID_HANDLE_VALUE))
856 error (_("Failed to convert `%s' to event id"), args);
858 SetEvent ((HANDLE) event_id);
859 CloseHandle ((HANDLE) event_id);
862 /* Handle DEBUG_STRING output from child process.
863 Cygwin prepends its messages with a "cygwin:". Interpret this as
864 a Cygwin signal. Otherwise just print the string as a warning. */
866 handle_output_debug_string (struct target_waitstatus *ourstatus)
871 if (!target_read_string
872 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
876 else if (!startswith (s, _CYGWIN_SIGNAL_STRING))
879 if (!startswith (s, "cYg"))
882 char *p = strchr (s, '\0');
884 if (p > s && *--p == '\n')
892 /* Got a cygwin signal marker. A cygwin signal is followed by
893 the signal number itself and then optionally followed by the
894 thread id and address to saved context within the DLL. If
895 these are supplied, then the given thread is assumed to have
896 issued the signal and the context from the thread is assumed
897 to be stored at the given address in the inferior. Tell gdb
898 to treat this like a real signal. */
900 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
901 gdb_signal gotasig = gdb_signal_from_host (sig);
903 ourstatus->value.sig = gotasig;
909 ourstatus->kind = TARGET_WAITKIND_STOPPED;
910 retval = strtoul (p, &p, 0);
912 retval = main_thread_id;
913 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
914 && ReadProcessMemory (current_process_handle, x,
916 __COPY_CONTEXT_SIZE, &n)
917 && n == __COPY_CONTEXT_SIZE)
918 have_saved_context = 1;
929 display_selector (HANDLE thread, DWORD sel)
932 if (GetThreadSelectorEntry (thread, sel, &info))
935 printf_filtered ("0x%03x: ", (unsigned) sel);
936 if (!info.HighWord.Bits.Pres)
938 puts_filtered ("Segment not present\n");
941 base = (info.HighWord.Bits.BaseHi << 24) +
942 (info.HighWord.Bits.BaseMid << 16)
944 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
945 if (info.HighWord.Bits.Granularity)
946 limit = (limit << 12) | 0xfff;
947 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
948 if (info.HighWord.Bits.Default_Big)
949 puts_filtered(" 32-bit ");
951 puts_filtered(" 16-bit ");
952 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
955 puts_filtered ("Data (Read-Only, Exp-up");
958 puts_filtered ("Data (Read/Write, Exp-up");
961 puts_filtered ("Unused segment (");
964 puts_filtered ("Data (Read/Write, Exp-down");
967 puts_filtered ("Code (Exec-Only, N.Conf");
970 puts_filtered ("Code (Exec/Read, N.Conf");
973 puts_filtered ("Code (Exec-Only, Conf");
976 puts_filtered ("Code (Exec/Read, Conf");
979 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
981 if ((info.HighWord.Bits.Type & 0x1) == 0)
982 puts_filtered(", N.Acc");
983 puts_filtered (")\n");
984 if ((info.HighWord.Bits.Type & 0x10) == 0)
985 puts_filtered("System selector ");
986 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
987 if (info.HighWord.Bits.Granularity)
988 puts_filtered ("Page granular.\n");
990 puts_filtered ("Byte granular.\n");
995 DWORD err = GetLastError ();
996 if (err == ERROR_NOT_SUPPORTED)
997 printf_filtered ("Function not supported\n");
999 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1005 display_selectors (char * args, int from_tty)
1007 if (!current_thread)
1009 puts_filtered ("Impossible to display selectors now.\n");
1015 puts_filtered ("Selector $cs\n");
1016 display_selector (current_thread->h,
1017 current_thread->context.SegCs);
1018 puts_filtered ("Selector $ds\n");
1019 display_selector (current_thread->h,
1020 current_thread->context.SegDs);
1021 puts_filtered ("Selector $es\n");
1022 display_selector (current_thread->h,
1023 current_thread->context.SegEs);
1024 puts_filtered ("Selector $ss\n");
1025 display_selector (current_thread->h,
1026 current_thread->context.SegSs);
1027 puts_filtered ("Selector $fs\n");
1028 display_selector (current_thread->h,
1029 current_thread->context.SegFs);
1030 puts_filtered ("Selector $gs\n");
1031 display_selector (current_thread->h,
1032 current_thread->context.SegGs);
1037 sel = parse_and_eval_long (args);
1038 printf_filtered ("Selector \"%s\"\n",args);
1039 display_selector (current_thread->h, sel);
1043 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1044 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1045 host_address_to_string (\
1046 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1048 static handle_exception_result
1049 handle_exception (struct target_waitstatus *ourstatus)
1051 EXCEPTION_RECORD *rec = ¤t_event.u.Exception.ExceptionRecord;
1052 DWORD code = rec->ExceptionCode;
1053 handle_exception_result result = HANDLE_EXCEPTION_HANDLED;
1055 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1057 /* Record the context of the current thread. */
1058 thread_rec (current_event.dwThreadId, -1);
1062 case EXCEPTION_ACCESS_VIOLATION:
1063 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1064 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1067 /* See if the access violation happened within the cygwin DLL
1068 itself. Cygwin uses a kind of exception handling to deal
1069 with passed-in invalid addresses. gdb should not treat
1070 these as real SEGVs since they will be silently handled by
1071 cygwin. A real SEGV will (theoretically) be caught by
1072 cygwin later in the process and will be sent as a
1073 cygwin-specific-signal. So, ignore SEGVs if they show up
1074 within the text segment of the DLL itself. */
1076 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress;
1078 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1079 && addr < cygwin_load_end))
1080 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1081 && startswith (fn, "KERNEL32!IsBad")))
1082 return HANDLE_EXCEPTION_UNHANDLED;
1086 case STATUS_STACK_OVERFLOW:
1087 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1088 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1090 case STATUS_FLOAT_DENORMAL_OPERAND:
1091 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1092 ourstatus->value.sig = GDB_SIGNAL_FPE;
1094 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1095 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1096 ourstatus->value.sig = GDB_SIGNAL_FPE;
1098 case STATUS_FLOAT_INEXACT_RESULT:
1099 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1100 ourstatus->value.sig = GDB_SIGNAL_FPE;
1102 case STATUS_FLOAT_INVALID_OPERATION:
1103 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1104 ourstatus->value.sig = GDB_SIGNAL_FPE;
1106 case STATUS_FLOAT_OVERFLOW:
1107 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1108 ourstatus->value.sig = GDB_SIGNAL_FPE;
1110 case STATUS_FLOAT_STACK_CHECK:
1111 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1112 ourstatus->value.sig = GDB_SIGNAL_FPE;
1114 case STATUS_FLOAT_UNDERFLOW:
1115 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1116 ourstatus->value.sig = GDB_SIGNAL_FPE;
1118 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1119 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1120 ourstatus->value.sig = GDB_SIGNAL_FPE;
1122 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1123 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1124 ourstatus->value.sig = GDB_SIGNAL_FPE;
1126 case STATUS_INTEGER_OVERFLOW:
1127 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1128 ourstatus->value.sig = GDB_SIGNAL_FPE;
1130 case EXCEPTION_BREAKPOINT:
1131 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1132 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1135 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1136 ourstatus->value.sig = GDB_SIGNAL_INT;
1138 case DBG_CONTROL_BREAK:
1139 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1140 ourstatus->value.sig = GDB_SIGNAL_INT;
1142 case EXCEPTION_SINGLE_STEP:
1143 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1144 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1146 case EXCEPTION_ILLEGAL_INSTRUCTION:
1147 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1148 ourstatus->value.sig = GDB_SIGNAL_ILL;
1150 case EXCEPTION_PRIV_INSTRUCTION:
1151 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1152 ourstatus->value.sig = GDB_SIGNAL_ILL;
1154 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1155 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1156 ourstatus->value.sig = GDB_SIGNAL_ILL;
1158 case MS_VC_EXCEPTION:
1159 if (rec->NumberParameters >= 3
1160 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
1162 DWORD named_thread_id;
1163 windows_thread_info *named_thread;
1164 CORE_ADDR thread_name_target;
1166 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1168 thread_name_target = rec->ExceptionInformation[1];
1169 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]);
1171 if (named_thread_id == (DWORD) -1)
1172 named_thread_id = current_event.dwThreadId;
1174 named_thread = thread_rec (named_thread_id, 0);
1175 if (named_thread != NULL)
1177 int thread_name_len;
1180 thread_name_len = target_read_string (thread_name_target,
1181 &thread_name, 1025, NULL);
1182 if (thread_name_len > 0)
1184 thread_name[thread_name_len - 1] = '\0';
1185 xfree (named_thread->name);
1186 named_thread->name = thread_name;
1189 xfree (thread_name);
1191 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1192 result = HANDLE_EXCEPTION_IGNORED;
1195 /* treat improperly formed exception as unknown, fallthrough */
1197 /* Treat unhandled first chance exceptions specially. */
1198 if (current_event.u.Exception.dwFirstChance)
1199 return HANDLE_EXCEPTION_UNHANDLED;
1200 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1201 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1202 host_address_to_string (
1203 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1204 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1208 last_sig = ourstatus->value.sig;
1212 /* Resume thread specified by ID, or all artificially suspended
1213 threads, if we are continuing execution. KILLED non-zero means we
1214 have killed the inferior, so we should ignore weird errors due to
1215 threads shutting down. */
1217 windows_continue (DWORD continue_status, int id, int killed)
1220 windows_thread_info *th;
1223 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1224 (unsigned) current_event.dwProcessId,
1225 (unsigned) current_event.dwThreadId,
1226 continue_status == DBG_CONTINUE ?
1227 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1229 for (th = &thread_head; (th = th->next) != NULL;)
1230 if ((id == -1 || id == (int) th->id)
1233 if (debug_registers_changed)
1235 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1236 th->context.Dr0 = dr[0];
1237 th->context.Dr1 = dr[1];
1238 th->context.Dr2 = dr[2];
1239 th->context.Dr3 = dr[3];
1240 th->context.Dr6 = DR6_CLEAR_VALUE;
1241 th->context.Dr7 = dr[7];
1243 if (th->context.ContextFlags)
1247 if (GetExitCodeThread (th->h, &ec)
1248 && ec == STILL_ACTIVE)
1250 BOOL status = SetThreadContext (th->h, &th->context);
1255 th->context.ContextFlags = 0;
1257 if (th->suspended > 0)
1258 (void) ResumeThread (th->h);
1262 res = ContinueDebugEvent (current_event.dwProcessId,
1263 current_event.dwThreadId,
1267 error (_("Failed to resume program execution"
1268 " (ContinueDebugEvent failed, error %u)"),
1269 (unsigned int) GetLastError ());
1271 debug_registers_changed = 0;
1275 /* Called in pathological case where Windows fails to send a
1276 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1278 fake_create_process (void)
1280 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1281 current_event.dwProcessId);
1282 if (current_process_handle != NULL)
1283 open_process_used = 1;
1286 error (_("OpenProcess call failed, GetLastError = %u"),
1287 (unsigned) GetLastError ());
1288 /* We can not debug anything in that case. */
1290 main_thread_id = current_event.dwThreadId;
1291 current_thread = windows_add_thread (
1292 ptid_build (current_event.dwProcessId, 0,
1293 current_event.dwThreadId),
1294 current_event.u.CreateThread.hThread,
1295 current_event.u.CreateThread.lpThreadLocalBase);
1296 return main_thread_id;
1300 windows_resume (struct target_ops *ops,
1301 ptid_t ptid, int step, enum gdb_signal sig)
1303 windows_thread_info *th;
1304 DWORD continue_status = DBG_CONTINUE;
1306 /* A specific PTID means `step only this thread id'. */
1307 int resume_all = ptid_equal (ptid, minus_one_ptid);
1309 /* If we're continuing all threads, it's the current inferior that
1310 should be handled specially. */
1312 ptid = inferior_ptid;
1314 if (sig != GDB_SIGNAL_0)
1316 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1318 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1320 else if (sig == last_sig)
1321 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1324 /* This code does not seem to work, because
1325 the kernel does probably not consider changes in the ExceptionRecord
1326 structure when passing the exception to the inferior.
1327 Note that this seems possible in the exception handler itself. */
1330 for (i = 0; xlate[i].them != -1; i++)
1331 if (xlate[i].us == sig)
1333 current_event.u.Exception.ExceptionRecord.ExceptionCode
1335 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1338 if (continue_status == DBG_CONTINUE)
1340 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1344 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1348 last_sig = GDB_SIGNAL_0;
1350 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1351 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1353 /* Get context for currently selected thread. */
1354 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1359 /* Single step by setting t bit. */
1360 struct regcache *regcache = get_current_regcache ();
1361 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1362 windows_fetch_inferior_registers (ops, regcache,
1363 gdbarch_ps_regnum (gdbarch));
1364 th->context.EFlags |= FLAG_TRACE_BIT;
1367 if (th->context.ContextFlags)
1369 if (debug_registers_changed)
1371 th->context.Dr0 = dr[0];
1372 th->context.Dr1 = dr[1];
1373 th->context.Dr2 = dr[2];
1374 th->context.Dr3 = dr[3];
1375 th->context.Dr6 = DR6_CLEAR_VALUE;
1376 th->context.Dr7 = dr[7];
1378 CHECK (SetThreadContext (th->h, &th->context));
1379 th->context.ContextFlags = 0;
1383 /* Allow continuing with the same signal that interrupted us.
1384 Otherwise complain. */
1387 windows_continue (continue_status, -1, 0);
1389 windows_continue (continue_status, ptid_get_tid (ptid), 0);
1392 /* Ctrl-C handler used when the inferior is not run in the same console. The
1393 handler is in charge of interrupting the inferior using DebugBreakProcess.
1394 Note that this function is not available prior to Windows XP. In this case
1395 we emit a warning. */
1397 ctrl_c_handler (DWORD event_type)
1399 const int attach_flag = current_inferior ()->attach_flag;
1401 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1402 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1405 /* If the inferior and the debugger share the same console, do nothing as
1406 the inferior has also received the Ctrl-C event. */
1407 if (!new_console && !attach_flag)
1410 if (!DebugBreakProcess (current_process_handle))
1411 warning (_("Could not interrupt program. "
1412 "Press Ctrl-c in the program console."));
1414 /* Return true to tell that Ctrl-C has been handled. */
1418 /* Get the next event from the child. Returns a non-zero thread id if the event
1419 requires handling by WFI (or whatever). */
1421 get_windows_debug_event (struct target_ops *ops,
1422 int pid, struct target_waitstatus *ourstatus)
1425 DWORD continue_status, event_code;
1426 windows_thread_info *th;
1427 static windows_thread_info dummy_thread_info;
1428 DWORD thread_id = 0;
1430 last_sig = GDB_SIGNAL_0;
1432 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1436 continue_status = DBG_CONTINUE;
1438 event_code = current_event.dwDebugEventCode;
1439 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1441 have_saved_context = 0;
1445 case CREATE_THREAD_DEBUG_EVENT:
1446 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1447 (unsigned) current_event.dwProcessId,
1448 (unsigned) current_event.dwThreadId,
1449 "CREATE_THREAD_DEBUG_EVENT"));
1450 if (saw_create != 1)
1452 struct inferior *inf;
1453 inf = find_inferior_pid (current_event.dwProcessId);
1454 if (!saw_create && inf->attach_flag)
1456 /* Kludge around a Windows bug where first event is a create
1457 thread event. Caused when attached process does not have
1459 thread_id = fake_create_process ();
1465 /* Record the existence of this thread. */
1466 thread_id = current_event.dwThreadId;
1467 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1468 current_event.dwThreadId),
1469 current_event.u.CreateThread.hThread,
1470 current_event.u.CreateThread.lpThreadLocalBase);
1474 case EXIT_THREAD_DEBUG_EVENT:
1475 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1476 (unsigned) current_event.dwProcessId,
1477 (unsigned) current_event.dwThreadId,
1478 "EXIT_THREAD_DEBUG_EVENT"));
1480 if (current_event.dwThreadId != main_thread_id)
1482 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1483 current_event.dwThreadId),
1484 current_event.u.ExitThread.dwExitCode);
1485 th = &dummy_thread_info;
1489 case CREATE_PROCESS_DEBUG_EVENT:
1490 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1491 (unsigned) current_event.dwProcessId,
1492 (unsigned) current_event.dwThreadId,
1493 "CREATE_PROCESS_DEBUG_EVENT"));
1494 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1495 if (++saw_create != 1)
1498 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1500 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1503 main_thread_id = current_event.dwThreadId;
1504 /* Add the main thread. */
1505 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1506 current_event.dwThreadId),
1507 current_event.u.CreateProcessInfo.hThread,
1508 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1509 thread_id = current_event.dwThreadId;
1512 case EXIT_PROCESS_DEBUG_EVENT:
1513 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1514 (unsigned) current_event.dwProcessId,
1515 (unsigned) current_event.dwThreadId,
1516 "EXIT_PROCESS_DEBUG_EVENT"));
1517 if (!windows_initialization_done)
1519 target_terminal_ours ();
1520 target_mourn_inferior (inferior_ptid);
1521 error (_("During startup program exited with code 0x%x."),
1522 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1524 else if (saw_create == 1)
1526 ourstatus->kind = TARGET_WAITKIND_EXITED;
1527 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1528 thread_id = main_thread_id;
1532 case LOAD_DLL_DEBUG_EVENT:
1533 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1534 (unsigned) current_event.dwProcessId,
1535 (unsigned) current_event.dwThreadId,
1536 "LOAD_DLL_DEBUG_EVENT"));
1537 CloseHandle (current_event.u.LoadDll.hFile);
1538 if (saw_create != 1 || ! windows_initialization_done)
1540 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1541 ourstatus->kind = TARGET_WAITKIND_LOADED;
1542 ourstatus->value.integer = 0;
1543 thread_id = main_thread_id;
1546 case UNLOAD_DLL_DEBUG_EVENT:
1547 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1548 (unsigned) current_event.dwProcessId,
1549 (unsigned) current_event.dwThreadId,
1550 "UNLOAD_DLL_DEBUG_EVENT"));
1551 if (saw_create != 1 || ! windows_initialization_done)
1553 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1554 ourstatus->kind = TARGET_WAITKIND_LOADED;
1555 ourstatus->value.integer = 0;
1556 thread_id = main_thread_id;
1559 case EXCEPTION_DEBUG_EVENT:
1560 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1561 (unsigned) current_event.dwProcessId,
1562 (unsigned) current_event.dwThreadId,
1563 "EXCEPTION_DEBUG_EVENT"));
1564 if (saw_create != 1)
1566 switch (handle_exception (ourstatus))
1568 case HANDLE_EXCEPTION_UNHANDLED:
1570 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1572 case HANDLE_EXCEPTION_HANDLED:
1573 thread_id = current_event.dwThreadId;
1575 case HANDLE_EXCEPTION_IGNORED:
1576 continue_status = DBG_CONTINUE;
1581 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1582 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1583 (unsigned) current_event.dwProcessId,
1584 (unsigned) current_event.dwThreadId,
1585 "OUTPUT_DEBUG_STRING_EVENT"));
1586 if (saw_create != 1)
1588 thread_id = handle_output_debug_string (ourstatus);
1592 if (saw_create != 1)
1594 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1595 (unsigned) current_event.dwProcessId,
1596 (unsigned) current_event.dwThreadId);
1597 printf_unfiltered (" unknown event code %u\n",
1598 (unsigned) current_event.dwDebugEventCode);
1602 if (!thread_id || saw_create != 1)
1604 CHECK (windows_continue (continue_status, -1, 0));
1608 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1610 current_thread = th;
1611 if (!current_thread)
1612 current_thread = thread_rec (thread_id, TRUE);
1619 /* Wait for interesting events to occur in the target process. */
1621 windows_wait (struct target_ops *ops,
1622 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1626 target_terminal_ours ();
1628 /* We loop when we get a non-standard exception rather than return
1629 with a SPURIOUS because resume can try and step or modify things,
1630 which needs a current_thread->h. But some of these exceptions mark
1631 the birth or death of threads, which mean that the current thread
1632 isn't necessarily what you think it is. */
1638 /* If the user presses Ctrl-c while the debugger is waiting
1639 for an event, he expects the debugger to interrupt his program
1640 and to get the prompt back. There are two possible situations:
1642 - The debugger and the program do not share the console, in
1643 which case the Ctrl-c event only reached the debugger.
1644 In that case, the ctrl_c handler will take care of interrupting
1645 the inferior. Note that this case is working starting with
1646 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1649 - The debugger and the program share the same console, in which
1650 case both debugger and inferior will receive the Ctrl-c event.
1651 In that case the ctrl_c handler will ignore the event, as the
1652 Ctrl-c event generated inside the inferior will trigger the
1653 expected debug event.
1655 FIXME: brobecker/2008-05-20: If the inferior receives the
1656 signal first and the delay until GDB receives that signal
1657 is sufficiently long, GDB can sometimes receive the SIGINT
1658 after we have unblocked the CTRL+C handler. This would
1659 lead to the debugger stopping prematurely while handling
1660 the new-thread event that comes with the handling of the SIGINT
1661 inside the inferior, and then stop again immediately when
1662 the user tries to resume the execution in the inferior.
1663 This is a classic race that we should try to fix one day. */
1664 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1665 retval = get_windows_debug_event (ops, pid, ourstatus);
1666 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1669 return ptid_build (current_event.dwProcessId, 0, retval);
1674 if (deprecated_ui_loop_hook != NULL)
1675 detach = deprecated_ui_loop_hook (0);
1678 windows_kill_inferior (ops);
1683 /* Iterate over all DLLs currently mapped by our inferior, and
1684 add them to our list of solibs. */
1687 windows_add_all_dlls (void)
1690 HMODULE dummy_hmodule;
1695 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1696 sizeof (HMODULE), &cb_needed) == 0)
1702 hmodules = (HMODULE *) alloca (cb_needed);
1703 if (EnumProcessModules (current_process_handle, hmodules,
1704 cb_needed, &cb_needed) == 0)
1707 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1711 wchar_t dll_name[__PMAX];
1714 char dll_name[__PMAX];
1717 if (GetModuleInformation (current_process_handle, hmodules[i],
1718 &mi, sizeof (mi)) == 0)
1720 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1721 dll_name, sizeof (dll_name)) == 0)
1724 wcstombs (name, dll_name, __PMAX);
1729 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1730 solib_end = solib_end->next;
1735 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1738 struct inferior *inf;
1739 struct thread_info *tp;
1741 last_sig = GDB_SIGNAL_0;
1743 exception_count = 0;
1744 open_process_used = 0;
1745 debug_registers_changed = 0;
1746 debug_registers_used = 0;
1747 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1750 cygwin_load_start = cygwin_load_end = 0;
1752 current_event.dwProcessId = pid;
1753 memset (¤t_event, 0, sizeof (current_event));
1754 if (!target_is_pushed (ops))
1756 disable_breakpoints_in_shlibs ();
1757 windows_clear_solib ();
1758 clear_proceed_status (0);
1759 init_wait_for_inferior ();
1761 inf = current_inferior ();
1762 inferior_appeared (inf, pid);
1763 inf->attach_flag = attaching;
1765 /* Make the new process the current inferior, so terminal handling
1766 can rely on it. When attaching, we don't know about any thread
1767 id here, but that's OK --- nothing should be referencing the
1768 current thread until we report an event out of windows_wait. */
1769 inferior_ptid = pid_to_ptid (pid);
1771 target_terminal_init ();
1772 target_terminal_inferior ();
1774 windows_initialization_done = 0;
1778 struct target_waitstatus status;
1780 windows_wait (ops, minus_one_ptid, &status, 0);
1782 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1784 if (status.kind != TARGET_WAITKIND_LOADED
1785 && status.kind != TARGET_WAITKIND_SPURIOUS)
1788 windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0);
1791 /* Now that the inferior has been started and all DLLs have been mapped,
1792 we can iterate over all DLLs and load them in.
1794 We avoid doing it any earlier because, on certain versions of Windows,
1795 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1796 we have seen on Windows 8.1 that the ntdll.dll load event does not
1797 include the DLL name, preventing us from creating an associated SO.
1798 A possible explanation is that ntdll.dll might be mapped before
1799 the SO info gets created by the Windows system -- ntdll.dll is
1800 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1801 do not seem to suffer from that problem.
1803 Rather than try to work around this sort of issue, it is much
1804 simpler to just ignore DLL load/unload events during the startup
1805 phase, and then process them all in one batch now. */
1806 windows_add_all_dlls ();
1808 windows_initialization_done = 1;
1812 /* Try to set or remove a user privilege to the current process. Return -1
1813 if that fails, the previous setting of that privilege otherwise.
1815 This code is copied from the Cygwin source code and rearranged to allow
1816 dynamically loading of the needed symbols from advapi32 which is only
1817 available on NT/2K/XP. */
1819 set_process_privilege (const char *privilege, BOOL enable)
1821 HANDLE token_hdl = NULL;
1823 TOKEN_PRIVILEGES new_priv, orig_priv;
1827 if (!OpenProcessToken (GetCurrentProcess (),
1828 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1832 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1835 new_priv.PrivilegeCount = 1;
1836 new_priv.Privileges[0].Luid = restore_priv;
1837 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1839 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1840 sizeof orig_priv, &orig_priv, &size))
1843 /* Disabled, otherwise every `attach' in an unprivileged user session
1844 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1845 windows_attach(). */
1846 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1847 be enabled. GetLastError () returns an correct error code, though. */
1848 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1852 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1856 CloseHandle (token_hdl);
1861 /* Attach to process PID, then initialize for debugging it. */
1863 windows_attach (struct target_ops *ops, const char *args, int from_tty)
1868 pid = parse_pid_to_attach (args);
1870 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1872 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1873 printf_unfiltered ("This can cause attach to "
1874 "fail on Windows NT/2K/XP\n");
1877 windows_init_thread_list ();
1878 ok = DebugActiveProcess (pid);
1884 /* Try fall back to Cygwin pid. */
1885 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1888 ok = DebugActiveProcess (pid);
1893 error (_("Can't attach to process."));
1895 DebugSetProcessKillOnExit (FALSE);
1899 char *exec_file = (char *) get_exec_file (0);
1902 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1903 target_pid_to_str (pid_to_ptid (pid)));
1905 printf_unfiltered ("Attaching to %s\n",
1906 target_pid_to_str (pid_to_ptid (pid)));
1908 gdb_flush (gdb_stdout);
1911 do_initial_windows_stuff (ops, pid, 1);
1912 target_terminal_ours ();
1916 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1921 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1923 if (!DebugActiveProcessStop (current_event.dwProcessId))
1925 error (_("Can't detach process %u (error %u)"),
1926 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1929 DebugSetProcessKillOnExit (FALSE);
1931 if (detached && from_tty)
1933 char *exec_file = get_exec_file (0);
1936 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1937 (unsigned) current_event.dwProcessId);
1938 gdb_flush (gdb_stdout);
1941 x86_cleanup_dregs ();
1942 inferior_ptid = null_ptid;
1943 detach_inferior (current_event.dwProcessId);
1945 inf_child_maybe_unpush_target (ops);
1948 /* Try to determine the executable filename.
1950 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1952 Upon success, the filename is stored inside EXE_NAME_RET, and
1953 this function returns nonzero.
1955 Otherwise, this function returns zero and the contents of
1956 EXE_NAME_RET is undefined. */
1959 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1966 if (!EnumProcessModules (current_process_handle, &dh_buf,
1967 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1970 /* We know the executable is always first in the list of modules,
1971 which we just fetched. So no need to fetch more. */
1975 /* Cygwin prefers that the path be in /x/y/z format, so extract
1976 the filename into a temporary buffer first, and then convert it
1977 to POSIX format into the destination buffer. */
1978 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t));
1980 len = GetModuleFileNameEx (current_process_handle,
1981 dh_buf, pathbuf, exe_name_max_len);
1983 error (_("Error getting executable filename: %u."),
1984 (unsigned) GetLastError ());
1985 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
1986 exe_name_max_len) < 0)
1987 error (_("Error converting executable filename to POSIX: %d."), errno);
1990 len = GetModuleFileNameEx (current_process_handle,
1991 dh_buf, exe_name_ret, exe_name_max_len);
1993 error (_("Error getting executable filename: %u."),
1994 (unsigned) GetLastError ());
1997 return 1; /* success */
2000 /* The pid_to_exec_file target_ops method for this platform. */
2003 windows_pid_to_exec_file (struct target_ops *self, int pid)
2005 static char path[__PMAX];
2007 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2009 char procexe[sizeof ("/proc/4294967295/exe")];
2011 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
2012 nchars = readlink (procexe, path, sizeof(path));
2013 if (nchars > 0 && nchars < sizeof (path))
2015 path[nchars] = '\0'; /* Got it */
2020 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2021 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2022 if (!windows_get_exec_module_filename (path, sizeof (path)))
2028 /* Print status information about what we're accessing. */
2031 windows_files_info (struct target_ops *ignore)
2033 struct inferior *inf = current_inferior ();
2035 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2036 inf->attach_flag ? "attached" : "child",
2037 target_pid_to_str (inferior_ptid));
2040 /* Modify CreateProcess parameters for use of a new separate console.
2042 *FLAGS: DWORD parameter for general process creation flags.
2043 *SI: STARTUPINFO structure, for which the console window size and
2044 console buffer size is filled in if GDB is running in a console.
2045 to create the new console.
2046 The size of the used font is not available on all versions of
2047 Windows OS. Furthermore, the current font might not be the default
2048 font, but this is still better than before.
2049 If the windows and buffer sizes are computed,
2050 SI->DWFLAGS is changed so that this information is used
2051 by CreateProcess function. */
2054 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2056 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2057 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2059 if (hconsole != INVALID_HANDLE_VALUE)
2061 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2063 CONSOLE_FONT_INFO cfi;
2065 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2066 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2067 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2068 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2069 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2071 si->dwXSize *= font_size.X;
2075 si->dwYSize *= font_size.Y;
2078 si->dwXCountChars = sbinfo.dwSize.X;
2079 si->dwYCountChars = sbinfo.dwSize.Y;
2080 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2082 *flags |= CREATE_NEW_CONSOLE;
2086 /* Function called by qsort to sort environment strings. */
2089 envvar_cmp (const void *a, const void *b)
2091 const char **p = (const char **) a;
2092 const char **q = (const char **) b;
2093 return strcasecmp (*p, *q);
2099 clear_win32_environment (char **env)
2103 wchar_t *copy = NULL, *equalpos;
2105 for (i = 0; env[i] && *env[i]; i++)
2107 len = mbstowcs (NULL, env[i], 0) + 1;
2108 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2109 mbstowcs (copy, env[i], len);
2110 equalpos = wcschr (copy, L'=');
2113 SetEnvironmentVariableW (copy, NULL);
2121 /* Redirection of inferior I/O streams for native MS-Windows programs.
2122 Unlike on Unix, where this is handled by invoking the inferior via
2123 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2125 The official documentation of the cmd.exe redirection features is here:
2127 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2129 (That page talks about Windows XP, but there's no newer
2130 documentation, so we assume later versions of cmd.exe didn't change
2133 Caveat: the documentation on that page seems to include a few lies.
2134 For example, it describes strange constructs 1<&2 and 2<&1, which
2135 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2136 think the cmd.exe parser of the redirection symbols simply doesn't
2137 care about the < vs > distinction in these cases. Therefore, the
2138 supported features are explicitly documented below.
2140 The emulation below aims at supporting all the valid use cases
2141 supported by cmd.exe, which include:
2143 < FILE redirect standard input from FILE
2144 0< FILE redirect standard input from FILE
2145 <&N redirect standard input from file descriptor N
2146 0<&N redirect standard input from file descriptor N
2147 > FILE redirect standard output to FILE
2148 >> FILE append standard output to FILE
2149 1>> FILE append standard output to FILE
2150 >&N redirect standard output to file descriptor N
2151 1>&N redirect standard output to file descriptor N
2152 >>&N append standard output to file descriptor N
2153 1>>&N append standard output to file descriptor N
2154 2> FILE redirect standard error to FILE
2155 2>> FILE append standard error to FILE
2156 2>&N redirect standard error to file descriptor N
2157 2>>&N append standard error to file descriptor N
2159 Note that using N > 2 in the above construct is supported, but
2160 requires that the corresponding file descriptor be open by some
2161 means elsewhere or outside GDB. Also note that using ">&0" or
2162 "<&2" will generally fail, because the file descriptor redirected
2163 from is normally open in an incompatible mode (e.g., FD 0 is open
2164 for reading only). IOW, use of such tricks is not recommended;
2165 you are on your own.
2167 We do NOT support redirection of file descriptors above 2, as in
2168 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2169 that needs special handling in the startup code that MinGW
2170 doesn't have). Pipes are also not supported.
2172 As for invalid use cases, where the redirection contains some
2173 error, the emulation below will detect that and produce some
2174 error and/or failure. But the behavior in those cases is not
2175 bug-for-bug compatible with what cmd.exe does in those cases.
2176 That's because what cmd.exe does then is not well defined, and
2177 seems to be a side effect of the cmd.exe parsing of the command
2178 line more than anything else. For example, try redirecting to an
2179 invalid file name, as in "> foo:bar".
2181 There are also minor syntactic deviations from what cmd.exe does
2182 in some corner cases. For example, it doesn't support the likes
2183 of "> &foo" to mean redirect to file named literally "&foo"; we
2184 do support that here, because that, too, sounds like some issue
2185 with the cmd.exe parser. Another nicety is that we support
2186 redirection targets that use file names with forward slashes,
2187 something cmd.exe doesn't -- this comes in handy since GDB
2188 file-name completion can be used when typing the command line for
2191 /* Support routines for redirecting standard handles of the inferior. */
2193 /* Parse a single redirection spec, open/duplicate the specified
2194 file/fd, and assign the appropriate value to one of the 3 standard
2195 file descriptors. */
2197 redir_open (const char *redir_string, int *inp, int *out, int *err)
2199 int *fd, ref_fd = -2;
2201 const char *fname = redir_string + 1;
2202 int rc = *redir_string;
2217 fd = (rc == '2') ? err : out;
2218 mode = O_WRONLY | O_CREAT;
2231 if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9')
2233 /* A reference to a file descriptor. */
2235 ref_fd = (int) strtol (fname + 1, &fdtail, 10);
2236 if (fdtail > fname + 1 && *fdtail == '\0')
2238 /* Don't allow redirection when open modes are incompatible. */
2239 if ((ref_fd == 0 && (fd == out || fd == err))
2240 || ((ref_fd == 1 || ref_fd == 2) && fd == inp))
2247 else if (ref_fd == 1)
2249 else if (ref_fd == 2)
2259 fname++; /* skip the separator space */
2260 /* If the descriptor is already open, close it. This allows
2261 multiple specs of redirections for the same stream, which is
2262 somewhat nonsensical, but still valid and supported by cmd.exe.
2263 (But cmd.exe only opens a single file in this case, the one
2264 specified by the last redirection spec on the command line.) */
2269 *fd = _open (fname, mode, _S_IREAD | _S_IWRITE);
2273 else if (ref_fd == -1)
2274 *fd = -1; /* reset to default destination */
2277 *fd = _dup (ref_fd);
2281 /* _open just sets a flag for O_APPEND, which won't be passed to the
2282 inferior, so we need to actually move the file pointer. */
2283 if ((mode & O_APPEND) != 0)
2284 _lseek (*fd, 0L, SEEK_END);
2288 /* Canonicalize a single redirection spec and set up the corresponding
2289 file descriptor as specified. */
2291 redir_set_redirection (const char *s, int *inp, int *out, int *err)
2293 char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */
2295 const char *start = s;
2298 *d++ = *s++; /* copy the 1st character, < or > or a digit */
2299 if ((*start == '>' || *start == '1' || *start == '2')
2303 if (*s == '>' && *start != '>')
2306 else if (*start == '0' && *s == '<')
2308 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2311 while (isspace (*s)) /* skip whitespace before file name */
2313 *d++ = ' '; /* separate file name with a single space */
2316 /* Copy the file name. */
2319 /* Remove quoting characters from the file name in buf[]. */
2320 if (*s == '"') /* could support '..' quoting here */
2324 else if (*s == quote)
2332 else if (*s == '\\')
2334 if (s[1] == '"') /* could support '..' here */
2338 else if (isspace (*s) && !quote)
2342 if (d - buf >= sizeof (buf) - 1)
2344 errno = ENAMETOOLONG;
2350 /* Windows doesn't allow redirection characters in file names, so we
2351 can bail out early if they use them, or if there's no target file
2352 name after the redirection symbol. */
2353 if (d[-1] == '>' || d[-1] == '<')
2358 if (redir_open (buf, inp, out, err) == 0)
2363 /* Parse the command line for redirection specs and prepare the file
2364 descriptors for the 3 standard streams accordingly. */
2366 redirect_inferior_handles (const char *cmd_orig, char *cmd,
2367 int *inp, int *out, int *err)
2369 const char *s = cmd_orig;
2372 bool retval = false;
2374 while (isspace (*s))
2379 if (*s == '"') /* could also support '..' quoting here */
2383 else if (*s == quote)
2386 else if (*s == '\\')
2388 if (s[1] == '"') /* escaped quote char */
2393 /* Process a single redirection candidate. */
2394 if (*s == '<' || *s == '>'
2395 || ((*s == '1' || *s == '2') && s[1] == '>')
2396 || (*s == '0' && s[1] == '<'))
2398 int skip = redir_set_redirection (s, inp, out, err);
2412 #endif /* !__CYGWIN__ */
2414 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2415 EXEC_FILE is the file to run.
2416 ALLARGS is a string containing the arguments to the program.
2417 ENV is the environment vector to pass. Errors reported with error(). */
2420 windows_create_inferior (struct target_ops *ops, char *exec_file,
2421 char *allargs, char **in_env, int from_tty)
2425 cygwin_buf_t real_path[__PMAX];
2426 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2428 cygwin_buf_t *toexec;
2429 cygwin_buf_t *cygallargs;
2431 char **old_env = NULL;
2435 int ostdin, ostdout, ostderr;
2436 #else /* !__CYGWIN__ */
2437 char real_path[__PMAX];
2438 char shell[__PMAX]; /* Path to shell */
2440 char *args, *allargs_copy;
2441 size_t args_len, allargs_len;
2442 int fd_inp = -1, fd_out = -1, fd_err = -1;
2443 HANDLE tty = INVALID_HANDLE_VALUE;
2444 HANDLE inf_stdin = INVALID_HANDLE_VALUE;
2445 HANDLE inf_stdout = INVALID_HANDLE_VALUE;
2446 HANDLE inf_stderr = INVALID_HANDLE_VALUE;
2447 bool redirected = false;
2454 #endif /* !__CYGWIN__ */
2455 PROCESS_INFORMATION pi;
2458 const char *inferior_io_terminal = get_inferior_io_terminal ();
2461 error (_("No executable specified, use `target exec'."));
2463 memset (&si, 0, sizeof (si));
2464 si.cb = sizeof (si);
2467 flags |= CREATE_NEW_PROCESS_GROUP;
2470 windows_set_console_info (&si, &flags);
2475 flags |= DEBUG_ONLY_THIS_PROCESS;
2476 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2477 __PMAX * sizeof (cygwin_buf_t)) < 0)
2478 error (_("Error starting executable: %d"), errno);
2481 len = mbstowcs (NULL, allargs, 0) + 1;
2482 if (len == (size_t) -1)
2483 error (_("Error starting executable: %d"), errno);
2484 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2485 mbstowcs (cygallargs, allargs, len);
2486 #else /* !__USEWIDE */
2487 cygallargs = allargs;
2492 sh = getenv ("SHELL");
2495 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2496 error (_("Error starting executable via shell: %d"), errno);
2498 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2499 + mbstowcs (NULL, allargs, 0) + 2;
2500 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2501 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2502 #else /* !__USEWIDE */
2503 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2504 + strlen (allargs) + 2);
2505 cygallargs = (char *) alloca (len);
2506 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2507 #endif /* __USEWIDE */
2509 flags |= DEBUG_PROCESS;
2513 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2514 * sizeof (wchar_t));
2515 wcscpy (args, toexec);
2516 wcscat (args, L" ");
2517 wcscat (args, cygallargs);
2518 #else /* !__USEWIDE */
2519 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2520 strcpy (args, toexec);
2522 strcat (args, cygallargs);
2523 #endif /* !__USEWIDE */
2525 #ifdef CW_CVT_ENV_TO_WINENV
2526 /* First try to create a direct Win32 copy of the POSIX environment. */
2527 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2528 if (w32_env != (PWCHAR) -1)
2529 flags |= CREATE_UNICODE_ENVIRONMENT;
2531 /* If that fails, fall back to old method tweaking GDB's environment. */
2532 #endif /* CW_CVT_ENV_TO_WINENV */
2534 /* Reset all Win32 environment variables to avoid leftover on next run. */
2535 clear_win32_environment (environ);
2536 /* Prepare the environment vars for CreateProcess. */
2539 cygwin_internal (CW_SYNC_WINENV);
2543 if (!inferior_io_terminal)
2544 tty = ostdin = ostdout = ostderr = -1;
2547 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2550 print_sys_errmsg (inferior_io_terminal, errno);
2551 ostdin = ostdout = ostderr = -1;
2564 windows_init_thread_list ();
2565 ret = CreateProcess (0,
2566 args, /* command line */
2567 NULL, /* Security */
2569 TRUE, /* inherit handles */
2570 flags, /* start flags */
2571 w32_env, /* environment */
2572 NULL, /* current directory */
2576 /* Just free the Win32 environment, if it could be created. */
2580 /* Reset all environment variables to avoid leftover on next run. */
2581 clear_win32_environment (in_env);
2582 /* Restore normal GDB environment variables. */
2584 cygwin_internal (CW_SYNC_WINENV);
2597 #else /* !__CYGWIN__ */
2598 allargs_len = strlen (allargs);
2599 allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs);
2600 if (strpbrk (allargs_copy, "<>") != NULL)
2605 redirect_inferior_handles (allargs, allargs_copy,
2606 &fd_inp, &fd_out, &fd_err);
2608 warning (_("Error in redirection: %s."), strerror (errno));
2611 allargs_len = strlen (allargs_copy);
2613 /* If not all the standard streams are redirected by the command
2614 line, use inferior_io_terminal for those which aren't. */
2615 if (inferior_io_terminal
2616 && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0))
2618 SECURITY_ATTRIBUTES sa;
2619 sa.nLength = sizeof(sa);
2620 sa.lpSecurityDescriptor = 0;
2621 sa.bInheritHandle = TRUE;
2622 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2623 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2624 if (tty == INVALID_HANDLE_VALUE)
2625 warning (_("Warning: Failed to open TTY %s, error %#x."),
2626 inferior_io_terminal, (unsigned) GetLastError ());
2628 if (redirected || tty != INVALID_HANDLE_VALUE)
2631 si.hStdInput = (HANDLE) _get_osfhandle (fd_inp);
2632 else if (tty != INVALID_HANDLE_VALUE)
2635 si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
2637 si.hStdOutput = (HANDLE) _get_osfhandle (fd_out);
2638 else if (tty != INVALID_HANDLE_VALUE)
2639 si.hStdOutput = tty;
2641 si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
2643 si.hStdError = (HANDLE) _get_osfhandle (fd_err);
2644 else if (tty != INVALID_HANDLE_VALUE)
2647 si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
2648 si.dwFlags |= STARTF_USESTDHANDLES;
2652 /* Build the command line, a space-separated list of tokens where
2653 the first token is the name of the module to be executed.
2654 To avoid ambiguities introduced by spaces in the module name,
2656 args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2;
2657 args = (char *) alloca (args_len);
2658 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy);
2660 flags |= DEBUG_ONLY_THIS_PROCESS;
2662 /* CreateProcess takes the environment list as a null terminated set of
2663 strings (i.e. two nulls terminate the list). */
2665 /* Get total size for env strings. */
2666 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2667 envlen += strlen (in_env[i]) + 1;
2669 envsize = sizeof (in_env[0]) * (i + 1);
2670 env = (char **) alloca (envsize);
2671 memcpy (env, in_env, envsize);
2672 /* Windows programs expect the environment block to be sorted. */
2673 qsort (env, i, sizeof (char *), envvar_cmp);
2675 w32env = (char *) alloca (envlen + 1);
2677 /* Copy env strings into new buffer. */
2678 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2680 strcpy (temp, env[i]);
2681 temp += strlen (temp) + 1;
2684 /* Final nil string to terminate new env. */
2687 windows_init_thread_list ();
2688 ret = CreateProcessA (0,
2689 args, /* command line */
2690 NULL, /* Security */
2692 TRUE, /* inherit handles */
2693 flags, /* start flags */
2694 w32env, /* environment */
2695 NULL, /* current directory */
2698 if (tty != INVALID_HANDLE_VALUE)
2706 #endif /* !__CYGWIN__ */
2709 error (_("Error creating process %s, (error %u)."),
2710 exec_file, (unsigned) GetLastError ());
2712 CloseHandle (pi.hThread);
2713 CloseHandle (pi.hProcess);
2715 if (useshell && shell[0] != '\0')
2720 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2722 /* windows_continue (DBG_CONTINUE, -1, 0); */
2726 windows_mourn_inferior (struct target_ops *ops)
2728 (void) windows_continue (DBG_CONTINUE, -1, 0);
2729 x86_cleanup_dregs();
2730 if (open_process_used)
2732 CHECK (CloseHandle (current_process_handle));
2733 open_process_used = 0;
2735 inf_child_mourn_inferior (ops);
2738 /* Send a SIGINT to the process group. This acts just like the user typed a
2739 ^C on the controlling terminal. */
2742 windows_interrupt (struct target_ops *self, ptid_t ptid)
2744 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2745 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2746 registers_changed (); /* refresh register state */
2749 /* Helper for windows_xfer_partial that handles memory transfers.
2750 Arguments are like target_xfer_partial. */
2752 static enum target_xfer_status
2753 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2754 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2758 DWORD lasterror = 0;
2760 if (writebuf != NULL)
2762 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2763 pulongest (len), core_addr_to_string (memaddr)));
2764 success = WriteProcessMemory (current_process_handle,
2765 (LPVOID) (uintptr_t) memaddr, writebuf,
2768 lasterror = GetLastError ();
2769 FlushInstructionCache (current_process_handle,
2770 (LPCVOID) (uintptr_t) memaddr, len);
2774 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2775 pulongest (len), core_addr_to_string (memaddr)));
2776 success = ReadProcessMemory (current_process_handle,
2777 (LPCVOID) (uintptr_t) memaddr, readbuf,
2780 lasterror = GetLastError ();
2782 *xfered_len = (ULONGEST) done;
2783 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2784 return TARGET_XFER_OK;
2786 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2790 windows_kill_inferior (struct target_ops *ops)
2792 CHECK (TerminateProcess (current_process_handle, 0));
2796 if (!windows_continue (DBG_CONTINUE, -1, 1))
2798 if (!WaitForDebugEvent (¤t_event, INFINITE))
2800 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2804 target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */
2808 windows_close (struct target_ops *self)
2810 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2811 ptid_get_pid (inferior_ptid)));
2814 /* Convert pid to printable format. */
2816 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2818 static char buf[80];
2820 if (ptid_get_tid (ptid) != 0)
2822 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2823 ptid_get_pid (ptid), ptid_get_tid (ptid));
2827 return normal_pid_to_str (ptid);
2830 static enum target_xfer_status
2831 windows_xfer_shared_libraries (struct target_ops *ops,
2832 enum target_object object, const char *annex,
2833 gdb_byte *readbuf, const gdb_byte *writebuf,
2834 ULONGEST offset, ULONGEST len,
2835 ULONGEST *xfered_len)
2837 struct obstack obstack;
2843 return TARGET_XFER_E_IO;
2845 obstack_init (&obstack);
2846 obstack_grow_str (&obstack, "<library-list>\n");
2847 for (so = solib_start.next; so; so = so->next)
2848 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2849 (uintptr_t) so->lm_info->load_addr,
2850 target_gdbarch (), &obstack);
2851 obstack_grow_str0 (&obstack, "</library-list>\n");
2853 buf = (const char *) obstack_finish (&obstack);
2854 len_avail = strlen (buf);
2855 if (offset >= len_avail)
2859 if (len > len_avail - offset)
2860 len = len_avail - offset;
2861 memcpy (readbuf, buf + offset, len);
2864 obstack_free (&obstack, NULL);
2865 *xfered_len = (ULONGEST) len;
2866 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
2869 static enum target_xfer_status
2870 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2871 const char *annex, gdb_byte *readbuf,
2872 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2873 ULONGEST *xfered_len)
2877 case TARGET_OBJECT_MEMORY:
2878 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2880 case TARGET_OBJECT_LIBRARIES:
2881 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2882 writebuf, offset, len, xfered_len);
2885 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2886 readbuf, writebuf, offset, len,
2891 /* Provide thread local base, i.e. Thread Information Block address.
2892 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2895 windows_get_tib_address (struct target_ops *self,
2896 ptid_t ptid, CORE_ADDR *addr)
2898 windows_thread_info *th;
2900 th = thread_rec (ptid_get_tid (ptid), 0);
2905 *addr = th->thread_local_base;
2911 windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2913 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2916 /* Implementation of the to_thread_name method. */
2919 windows_thread_name (struct target_ops *self, struct thread_info *thr)
2921 return thread_rec (ptid_get_tid (thr->ptid), 0)->name;
2924 static struct target_ops *
2925 windows_target (void)
2927 struct target_ops *t = inf_child_target ();
2929 t->to_close = windows_close;
2930 t->to_attach = windows_attach;
2931 t->to_attach_no_wait = 1;
2932 t->to_detach = windows_detach;
2933 t->to_resume = windows_resume;
2934 t->to_wait = windows_wait;
2935 t->to_fetch_registers = windows_fetch_inferior_registers;
2936 t->to_store_registers = windows_store_inferior_registers;
2937 t->to_xfer_partial = windows_xfer_partial;
2938 t->to_files_info = windows_files_info;
2939 t->to_kill = windows_kill_inferior;
2940 t->to_create_inferior = windows_create_inferior;
2941 t->to_mourn_inferior = windows_mourn_inferior;
2942 t->to_thread_alive = windows_thread_alive;
2943 t->to_pid_to_str = windows_pid_to_str;
2944 t->to_interrupt = windows_interrupt;
2945 t->to_pid_to_exec_file = windows_pid_to_exec_file;
2946 t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
2947 t->to_get_tib_address = windows_get_tib_address;
2948 t->to_thread_name = windows_thread_name;
2953 /* -Wmissing-prototypes */
2954 extern initialize_file_ftype _initialize_windows_nat;
2957 _initialize_windows_nat (void)
2959 struct target_ops *t;
2961 t = windows_target ();
2963 x86_use_watchpoints (t);
2965 x86_dr_low.set_control = cygwin_set_dr7;
2966 x86_dr_low.set_addr = cygwin_set_dr;
2967 x86_dr_low.get_addr = cygwin_get_dr;
2968 x86_dr_low.get_status = cygwin_get_dr6;
2969 x86_dr_low.get_control = cygwin_get_dr7;
2971 /* x86_dr_low.debug_register_length field is set by
2972 calling x86_set_debug_register_length function
2973 in processor windows specific native file. */
2978 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2981 add_com ("signal-event", class_run, signal_event_command, _("\
2982 Signal a crashed process with event ID, to allow its debugging.\n\
2983 This command is needed in support of setting up GDB as JIT debugger on \
2984 MS-Windows. The command should be invoked from the GDB command line using \
2985 the '-ex' command-line option. The ID of the event that blocks the \
2986 crashed process will be supplied by the Windows JIT debugging mechanism."));
2989 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2990 Set use of shell to start subprocess."), _("\
2991 Show use of shell to start subprocess."), NULL,
2993 NULL, /* FIXME: i18n: */
2994 &setlist, &showlist);
2996 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
2997 &cygwin_exceptions, _("\
2998 Break when an exception is detected in the Cygwin DLL itself."), _("\
2999 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
3001 NULL, /* FIXME: i18n: */
3002 &setlist, &showlist);
3005 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
3006 Set creation of new console when creating child process."), _("\
3007 Show creation of new console when creating child process."), NULL,
3009 NULL, /* FIXME: i18n: */
3010 &setlist, &showlist);
3012 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
3013 Set creation of new group when creating child process."), _("\
3014 Show creation of new group when creating child process."), NULL,
3016 NULL, /* FIXME: i18n: */
3017 &setlist, &showlist);
3019 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
3020 Set whether to display execution in child process."), _("\
3021 Show whether to display execution in child process."), NULL,
3023 NULL, /* FIXME: i18n: */
3024 &setlist, &showlist);
3026 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
3027 Set whether to display kernel events in child process."), _("\
3028 Show whether to display kernel events in child process."), NULL,
3030 NULL, /* FIXME: i18n: */
3031 &setlist, &showlist);
3033 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
3034 Set whether to display memory accesses in child process."), _("\
3035 Show whether to display memory accesses in child process."), NULL,
3037 NULL, /* FIXME: i18n: */
3038 &setlist, &showlist);
3040 add_setshow_boolean_cmd ("debugexceptions", class_support,
3041 &debug_exceptions, _("\
3042 Set whether to display kernel exceptions in child process."), _("\
3043 Show whether to display kernel exceptions in child process."), NULL,
3045 NULL, /* FIXME: i18n: */
3046 &setlist, &showlist);
3048 init_w32_command_list ();
3050 add_cmd ("selector", class_info, display_selectors,
3051 _("Display selectors infos."),
3055 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3057 /* Pass the address ADDR to the inferior in the I'th debug register.
3058 Here we just store the address in dr array, the registers will be
3059 actually set up when windows_continue is called. */
3061 cygwin_set_dr (int i, CORE_ADDR addr)
3064 internal_error (__FILE__, __LINE__,
3065 _("Invalid register %d in cygwin_set_dr.\n"), i);
3067 debug_registers_changed = 1;
3068 debug_registers_used = 1;
3071 /* Pass the value VAL to the inferior in the DR7 debug control
3072 register. Here we just store the address in D_REGS, the watchpoint
3073 will be actually set up in windows_wait. */
3075 cygwin_set_dr7 (unsigned long val)
3077 dr[7] = (CORE_ADDR) val;
3078 debug_registers_changed = 1;
3079 debug_registers_used = 1;
3082 /* Get the value of debug register I from the inferior. */
3085 cygwin_get_dr (int i)
3090 /* Get the value of the DR6 debug status register from the inferior.
3091 Here we just return the value stored in dr[6]
3092 by the last call to thread_rec for current_event.dwThreadId id. */
3093 static unsigned long
3094 cygwin_get_dr6 (void)
3096 return (unsigned long) dr[6];
3099 /* Get the value of the DR7 debug status register from the inferior.
3100 Here we just return the value stored in dr[7] by the last call to
3101 thread_rec for current_event.dwThreadId id. */
3103 static unsigned long
3104 cygwin_get_dr7 (void)
3106 return (unsigned long) dr[7];
3109 /* Determine if the thread referenced by "ptid" is alive
3110 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3111 it means that the thread has died. Otherwise it is assumed to be alive. */
3113 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
3117 gdb_assert (ptid_get_tid (ptid) != 0);
3118 tid = ptid_get_tid (ptid);
3120 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
3124 /* -Wmissing-prototypes */
3125 extern initialize_file_ftype _initialize_check_for_gdb_ini;
3128 _initialize_check_for_gdb_ini (void)
3131 if (inhibit_gdbinit)
3134 homedir = getenv ("HOME");
3138 char *oldini = (char *) alloca (strlen (homedir) +
3139 sizeof ("gdb.ini") + 1);
3140 strcpy (oldini, homedir);
3141 p = strchr (oldini, '\0');
3142 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
3144 strcpy (p, "gdb.ini");
3145 if (access (oldini, 0) == 0)
3147 int len = strlen (oldini);
3148 char *newini = (char *) alloca (len + 2);
3150 xsnprintf (newini, len + 2, "%.*s.gdbinit",
3151 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
3152 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
3157 /* Define dummy functions which always return error for the rare cases where
3158 these functions could not be found. */
3160 bad_DebugActiveProcessStop (DWORD w)
3165 bad_DebugBreakProcess (HANDLE w)
3170 bad_DebugSetProcessKillOnExit (BOOL w)
3175 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
3182 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
3188 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
3195 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
3201 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
3207 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
3213 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
3221 /* -Wmissing-prototypes */
3222 extern initialize_file_ftype _initialize_loadable;
3224 /* Load any functions which may not be available in ancient versions
3228 _initialize_loadable (void)
3232 #define GPA(m, func) \
3233 func = (func ## _ftype *) GetProcAddress (m, #func)
3235 hm = LoadLibrary ("kernel32.dll");
3238 GPA (hm, DebugActiveProcessStop);
3239 GPA (hm, DebugBreakProcess);
3240 GPA (hm, DebugSetProcessKillOnExit);
3241 GPA (hm, GetConsoleFontSize);
3242 GPA (hm, DebugActiveProcessStop);
3243 GPA (hm, GetCurrentConsoleFont);
3246 /* Set variables to dummy versions of these processes if the function
3247 wasn't found in kernel32.dll. */
3248 if (!DebugBreakProcess)
3249 DebugBreakProcess = bad_DebugBreakProcess;
3250 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
3252 DebugActiveProcessStop = bad_DebugActiveProcessStop;
3253 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
3255 if (!GetConsoleFontSize)
3256 GetConsoleFontSize = bad_GetConsoleFontSize;
3257 if (!GetCurrentConsoleFont)
3258 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
3260 /* Load optional functions used for retrieving filename information
3261 associated with the currently debugged process or its dlls. */
3262 hm = LoadLibrary ("psapi.dll");
3265 GPA (hm, EnumProcessModules);
3266 GPA (hm, GetModuleInformation);
3267 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *)
3268 GetProcAddress (hm, GetModuleFileNameEx_name);
3271 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
3273 /* Set variables to dummy versions of these processes if the function
3274 wasn't found in psapi.dll. */
3275 EnumProcessModules = bad_EnumProcessModules;
3276 GetModuleInformation = bad_GetModuleInformation;
3277 GetModuleFileNameEx = bad_GetModuleFileNameEx;
3278 /* This will probably fail on Windows 9x/Me. Let the user know
3279 that we're missing some functionality. */
3281 cannot automatically find executable file or library to read symbols.\n\
3282 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3285 hm = LoadLibrary ("advapi32.dll");
3288 GPA (hm, OpenProcessToken);
3289 GPA (hm, LookupPrivilegeValueA);
3290 GPA (hm, AdjustTokenPrivileges);
3291 /* Only need to set one of these since if OpenProcessToken fails nothing
3293 if (!OpenProcessToken || !LookupPrivilegeValueA
3294 || !AdjustTokenPrivileges)
3295 OpenProcessToken = bad_OpenProcessToken;