1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2017 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,
464 windows_thread_info *th, int r)
466 char *context_offset = ((char *) &th->context) + mappings[r];
467 struct gdbarch *gdbarch = get_regcache_arch (regcache);
468 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
471 if (th->reload_context)
474 if (have_saved_context)
476 /* Lie about where the program actually is stopped since
477 cygwin has informed us that we should consider the signal
478 to have occurred at another location which is stored in
480 memcpy (&th->context, &saved_context,
481 __COPY_CONTEXT_SIZE);
482 have_saved_context = 0;
487 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
488 CHECK (GetThreadContext (th->h, &th->context));
489 /* Copy dr values from that thread.
490 But only if there were not modified since last stop.
492 if (!debug_registers_changed)
494 dr[0] = th->context.Dr0;
495 dr[1] = th->context.Dr1;
496 dr[2] = th->context.Dr2;
497 dr[3] = th->context.Dr3;
498 dr[6] = th->context.Dr6;
499 dr[7] = th->context.Dr7;
502 th->reload_context = 0;
505 if (r == I387_FISEG_REGNUM (tdep))
507 l = *((long *) context_offset) & 0xffff;
508 regcache_raw_supply (regcache, r, (char *) &l);
510 else if (r == I387_FOP_REGNUM (tdep))
512 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
513 regcache_raw_supply (regcache, r, (char *) &l);
515 else if (segment_register_p (r))
517 /* GDB treats segment registers as 32bit registers, but they are
518 in fact only 16 bits long. Make sure we do not read extra
519 bits from our source buffer. */
520 l = *((long *) context_offset) & 0xffff;
521 regcache_raw_supply (regcache, r, (char *) &l);
524 regcache_raw_supply (regcache, r, context_offset);
527 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
528 do_windows_fetch_inferior_registers (regcache, th, r);
533 windows_fetch_inferior_registers (struct target_ops *ops,
534 struct regcache *regcache, int r)
536 DWORD pid = ptid_get_tid (regcache_get_ptid (regcache));
537 windows_thread_info *th = thread_rec (pid, TRUE);
539 /* Check if TH exists. Windows sometimes uses a non-existent
540 thread id in its events. */
542 do_windows_fetch_inferior_registers (regcache, th, r);
546 do_windows_store_inferior_registers (const struct regcache *regcache,
547 windows_thread_info *th, int r)
550 regcache_raw_collect (regcache, r,
551 ((char *) &th->context) + mappings[r]);
554 for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
555 do_windows_store_inferior_registers (regcache, th, r);
559 /* Store a new register value into the context of the thread tied to
562 windows_store_inferior_registers (struct target_ops *ops,
563 struct regcache *regcache, int r)
565 DWORD pid = ptid_get_tid (regcache_get_ptid (regcache));
566 windows_thread_info *th = thread_rec (pid, TRUE);
568 /* Check if TH exists. Windows sometimes uses a non-existent
569 thread id in its events. */
571 do_windows_store_inferior_registers (regcache, th, 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. */
588 struct lm_info_windows : public lm_info_base
590 LPVOID load_addr = 0;
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 lm_info_windows *li = new lm_info_windows;
650 li->load_addr = load_addr;
651 strcpy (so->so_original_name, name);
653 strcpy (so->so_name, buf);
656 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
657 SO_NAME_MAX_PATH_SIZE);
660 char *rname = realpath (name, NULL);
661 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
663 strcpy (so->so_name, rname);
667 error (_("dll path too long"));
669 /* Record cygwin1.dll .text start/end. */
670 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
671 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
673 asection *text = NULL;
676 gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386", -1));
681 if (bfd_check_format (abfd.get (), bfd_object))
682 text = bfd_get_section_by_name (abfd.get (), ".text");
687 /* The symbols in a dll are offset by 0x1000, which is the
688 offset from 0 of the first byte in an image - because of the
689 file header and the section alignment. */
690 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
692 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd.get (),
701 get_image_name (HANDLE h, void *address, int unicode)
704 static char buf[__PMAX];
706 static char buf[(2 * __PMAX) + 1];
708 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
714 /* Attempt to read the name of the dll that was detected.
715 This is documented to work only when actively debugging
716 a program. It will not work for attached processes. */
720 /* See if we could read the address of a string, and that the
721 address isn't null. */
722 if (!ReadProcessMemory (h, address, &address_ptr,
723 sizeof (address_ptr), &done)
724 || done != sizeof (address_ptr) || !address_ptr)
727 /* Find the length of the string. */
728 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
729 && (b[0] != 0 || b[size - 1] != 0) && done == size)
733 ReadProcessMemory (h, address_ptr, buf, len, &done);
736 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
737 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
740 wcstombs (buf, unicode_address, __PMAX);
742 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
750 /* Handle a DLL load event, and return 1.
752 This function assumes that this event did not occur during inferior
753 initialization, where their event info may be incomplete (see
754 do_initial_windows_stuff and windows_add_all_dlls for more info
755 on how we handle DLL loading during that phase). */
758 handle_load_dll (void *dummy)
760 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
763 /* Try getting the DLL name via the lpImageName field of the event.
764 Note that Microsoft documents this fields as strictly optional,
765 in the sense that it might be NULL. And the first DLL event in
766 particular is explicitly documented as "likely not pass[ed]"
767 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
768 dll_name = get_image_name (current_process_handle,
769 event->lpImageName, event->fUnicode);
773 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
774 solib_end = solib_end->next;
776 lm_info_windows *li = (lm_info_windows *) solib_end->lm_info;
778 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
779 host_address_to_string (li->load_addr)));
785 windows_free_so (struct so_list *so)
787 lm_info_windows *li = (lm_info_windows *) so->lm_info;
793 /* Handle a DLL unload event.
794 Return 1 if successful, or zero otherwise.
796 This function assumes that this event did not occur during inferior
797 initialization, where their event info may be incomplete (see
798 do_initial_windows_stuff and windows_add_all_dlls for more info
799 on how we handle DLL loading during that phase). */
802 handle_unload_dll (void *dummy)
804 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
807 for (so = &solib_start; so->next != NULL; so = so->next)
809 lm_info_windows *li_next = (lm_info_windows *) so->next->lm_info;
811 if (li_next->load_addr == lpBaseOfDll)
813 struct so_list *sodel = so->next;
815 so->next = sodel->next;
818 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
820 windows_free_so (sodel);
825 /* We did not find any DLL that was previously loaded at this address,
826 so register a complaint. We do not report an error, because we have
827 observed that this may be happening under some circumstances. For
828 instance, running 32bit applications on x64 Windows causes us to receive
829 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
830 events are apparently caused by the WOW layer, the interface between
831 32bit and 64bit worlds). */
832 complaint (&symfile_complaints, _("dll starting at %s not found."),
833 host_address_to_string (lpBaseOfDll));
838 /* Clear list of loaded DLLs. */
840 windows_clear_solib (void)
842 solib_start.next = NULL;
843 solib_end = &solib_start;
847 signal_event_command (char *args, int from_tty)
849 uintptr_t event_id = 0;
850 char *endargs = NULL;
853 error (_("signal-event requires an argument (integer event id)"));
855 event_id = strtoumax (args, &endargs, 10);
857 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) ||
858 ((HANDLE) event_id == INVALID_HANDLE_VALUE))
859 error (_("Failed to convert `%s' to event id"), args);
861 SetEvent ((HANDLE) event_id);
862 CloseHandle ((HANDLE) event_id);
865 /* Handle DEBUG_STRING output from child process.
866 Cygwin prepends its messages with a "cygwin:". Interpret this as
867 a Cygwin signal. Otherwise just print the string as a warning. */
869 handle_output_debug_string (struct target_waitstatus *ourstatus)
874 if (!target_read_string
875 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
879 else if (!startswith (s, _CYGWIN_SIGNAL_STRING))
882 if (!startswith (s, "cYg"))
885 char *p = strchr (s, '\0');
887 if (p > s && *--p == '\n')
895 /* Got a cygwin signal marker. A cygwin signal is followed by
896 the signal number itself and then optionally followed by the
897 thread id and address to saved context within the DLL. If
898 these are supplied, then the given thread is assumed to have
899 issued the signal and the context from the thread is assumed
900 to be stored at the given address in the inferior. Tell gdb
901 to treat this like a real signal. */
903 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
904 gdb_signal gotasig = gdb_signal_from_host (sig);
906 ourstatus->value.sig = gotasig;
912 ourstatus->kind = TARGET_WAITKIND_STOPPED;
913 retval = strtoul (p, &p, 0);
915 retval = main_thread_id;
916 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
917 && ReadProcessMemory (current_process_handle, x,
919 __COPY_CONTEXT_SIZE, &n)
920 && n == __COPY_CONTEXT_SIZE)
921 have_saved_context = 1;
932 display_selector (HANDLE thread, DWORD sel)
935 if (GetThreadSelectorEntry (thread, sel, &info))
938 printf_filtered ("0x%03x: ", (unsigned) sel);
939 if (!info.HighWord.Bits.Pres)
941 puts_filtered ("Segment not present\n");
944 base = (info.HighWord.Bits.BaseHi << 24) +
945 (info.HighWord.Bits.BaseMid << 16)
947 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
948 if (info.HighWord.Bits.Granularity)
949 limit = (limit << 12) | 0xfff;
950 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
951 if (info.HighWord.Bits.Default_Big)
952 puts_filtered(" 32-bit ");
954 puts_filtered(" 16-bit ");
955 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
958 puts_filtered ("Data (Read-Only, Exp-up");
961 puts_filtered ("Data (Read/Write, Exp-up");
964 puts_filtered ("Unused segment (");
967 puts_filtered ("Data (Read/Write, Exp-down");
970 puts_filtered ("Code (Exec-Only, N.Conf");
973 puts_filtered ("Code (Exec/Read, N.Conf");
976 puts_filtered ("Code (Exec-Only, Conf");
979 puts_filtered ("Code (Exec/Read, Conf");
982 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
984 if ((info.HighWord.Bits.Type & 0x1) == 0)
985 puts_filtered(", N.Acc");
986 puts_filtered (")\n");
987 if ((info.HighWord.Bits.Type & 0x10) == 0)
988 puts_filtered("System selector ");
989 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
990 if (info.HighWord.Bits.Granularity)
991 puts_filtered ("Page granular.\n");
993 puts_filtered ("Byte granular.\n");
998 DWORD err = GetLastError ();
999 if (err == ERROR_NOT_SUPPORTED)
1000 printf_filtered ("Function not supported\n");
1002 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1008 display_selectors (char * args, int from_tty)
1010 if (!current_thread)
1012 puts_filtered ("Impossible to display selectors now.\n");
1018 puts_filtered ("Selector $cs\n");
1019 display_selector (current_thread->h,
1020 current_thread->context.SegCs);
1021 puts_filtered ("Selector $ds\n");
1022 display_selector (current_thread->h,
1023 current_thread->context.SegDs);
1024 puts_filtered ("Selector $es\n");
1025 display_selector (current_thread->h,
1026 current_thread->context.SegEs);
1027 puts_filtered ("Selector $ss\n");
1028 display_selector (current_thread->h,
1029 current_thread->context.SegSs);
1030 puts_filtered ("Selector $fs\n");
1031 display_selector (current_thread->h,
1032 current_thread->context.SegFs);
1033 puts_filtered ("Selector $gs\n");
1034 display_selector (current_thread->h,
1035 current_thread->context.SegGs);
1040 sel = parse_and_eval_long (args);
1041 printf_filtered ("Selector \"%s\"\n",args);
1042 display_selector (current_thread->h, sel);
1046 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1047 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1048 host_address_to_string (\
1049 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1051 static handle_exception_result
1052 handle_exception (struct target_waitstatus *ourstatus)
1054 EXCEPTION_RECORD *rec = ¤t_event.u.Exception.ExceptionRecord;
1055 DWORD code = rec->ExceptionCode;
1056 handle_exception_result result = HANDLE_EXCEPTION_HANDLED;
1058 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1060 /* Record the context of the current thread. */
1061 thread_rec (current_event.dwThreadId, -1);
1065 case EXCEPTION_ACCESS_VIOLATION:
1066 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1067 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1070 /* See if the access violation happened within the cygwin DLL
1071 itself. Cygwin uses a kind of exception handling to deal
1072 with passed-in invalid addresses. gdb should not treat
1073 these as real SEGVs since they will be silently handled by
1074 cygwin. A real SEGV will (theoretically) be caught by
1075 cygwin later in the process and will be sent as a
1076 cygwin-specific-signal. So, ignore SEGVs if they show up
1077 within the text segment of the DLL itself. */
1079 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress;
1081 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1082 && addr < cygwin_load_end))
1083 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1084 && startswith (fn, "KERNEL32!IsBad")))
1085 return HANDLE_EXCEPTION_UNHANDLED;
1089 case STATUS_STACK_OVERFLOW:
1090 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1091 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1093 case STATUS_FLOAT_DENORMAL_OPERAND:
1094 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1095 ourstatus->value.sig = GDB_SIGNAL_FPE;
1097 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1098 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1099 ourstatus->value.sig = GDB_SIGNAL_FPE;
1101 case STATUS_FLOAT_INEXACT_RESULT:
1102 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1103 ourstatus->value.sig = GDB_SIGNAL_FPE;
1105 case STATUS_FLOAT_INVALID_OPERATION:
1106 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1107 ourstatus->value.sig = GDB_SIGNAL_FPE;
1109 case STATUS_FLOAT_OVERFLOW:
1110 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1111 ourstatus->value.sig = GDB_SIGNAL_FPE;
1113 case STATUS_FLOAT_STACK_CHECK:
1114 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1115 ourstatus->value.sig = GDB_SIGNAL_FPE;
1117 case STATUS_FLOAT_UNDERFLOW:
1118 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1119 ourstatus->value.sig = GDB_SIGNAL_FPE;
1121 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1122 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1123 ourstatus->value.sig = GDB_SIGNAL_FPE;
1125 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1126 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1127 ourstatus->value.sig = GDB_SIGNAL_FPE;
1129 case STATUS_INTEGER_OVERFLOW:
1130 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1131 ourstatus->value.sig = GDB_SIGNAL_FPE;
1133 case EXCEPTION_BREAKPOINT:
1134 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1135 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1138 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1139 ourstatus->value.sig = GDB_SIGNAL_INT;
1141 case DBG_CONTROL_BREAK:
1142 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1143 ourstatus->value.sig = GDB_SIGNAL_INT;
1145 case EXCEPTION_SINGLE_STEP:
1146 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1147 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1149 case EXCEPTION_ILLEGAL_INSTRUCTION:
1150 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1151 ourstatus->value.sig = GDB_SIGNAL_ILL;
1153 case EXCEPTION_PRIV_INSTRUCTION:
1154 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1155 ourstatus->value.sig = GDB_SIGNAL_ILL;
1157 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1158 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1159 ourstatus->value.sig = GDB_SIGNAL_ILL;
1161 case MS_VC_EXCEPTION:
1162 if (rec->NumberParameters >= 3
1163 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
1165 DWORD named_thread_id;
1166 windows_thread_info *named_thread;
1167 CORE_ADDR thread_name_target;
1169 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1171 thread_name_target = rec->ExceptionInformation[1];
1172 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]);
1174 if (named_thread_id == (DWORD) -1)
1175 named_thread_id = current_event.dwThreadId;
1177 named_thread = thread_rec (named_thread_id, 0);
1178 if (named_thread != NULL)
1180 int thread_name_len;
1183 thread_name_len = target_read_string (thread_name_target,
1184 &thread_name, 1025, NULL);
1185 if (thread_name_len > 0)
1187 thread_name[thread_name_len - 1] = '\0';
1188 xfree (named_thread->name);
1189 named_thread->name = thread_name;
1192 xfree (thread_name);
1194 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1195 result = HANDLE_EXCEPTION_IGNORED;
1198 /* treat improperly formed exception as unknown, fallthrough */
1200 /* Treat unhandled first chance exceptions specially. */
1201 if (current_event.u.Exception.dwFirstChance)
1202 return HANDLE_EXCEPTION_UNHANDLED;
1203 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1204 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1205 host_address_to_string (
1206 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1207 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1211 last_sig = ourstatus->value.sig;
1215 /* Resume thread specified by ID, or all artificially suspended
1216 threads, if we are continuing execution. KILLED non-zero means we
1217 have killed the inferior, so we should ignore weird errors due to
1218 threads shutting down. */
1220 windows_continue (DWORD continue_status, int id, int killed)
1223 windows_thread_info *th;
1226 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1227 (unsigned) current_event.dwProcessId,
1228 (unsigned) current_event.dwThreadId,
1229 continue_status == DBG_CONTINUE ?
1230 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1232 for (th = &thread_head; (th = th->next) != NULL;)
1233 if ((id == -1 || id == (int) th->id)
1236 if (debug_registers_changed)
1238 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1239 th->context.Dr0 = dr[0];
1240 th->context.Dr1 = dr[1];
1241 th->context.Dr2 = dr[2];
1242 th->context.Dr3 = dr[3];
1243 th->context.Dr6 = DR6_CLEAR_VALUE;
1244 th->context.Dr7 = dr[7];
1246 if (th->context.ContextFlags)
1250 if (GetExitCodeThread (th->h, &ec)
1251 && ec == STILL_ACTIVE)
1253 BOOL status = SetThreadContext (th->h, &th->context);
1258 th->context.ContextFlags = 0;
1260 if (th->suspended > 0)
1261 (void) ResumeThread (th->h);
1265 res = ContinueDebugEvent (current_event.dwProcessId,
1266 current_event.dwThreadId,
1270 error (_("Failed to resume program execution"
1271 " (ContinueDebugEvent failed, error %u)"),
1272 (unsigned int) GetLastError ());
1274 debug_registers_changed = 0;
1278 /* Called in pathological case where Windows fails to send a
1279 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1281 fake_create_process (void)
1283 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1284 current_event.dwProcessId);
1285 if (current_process_handle != NULL)
1286 open_process_used = 1;
1289 error (_("OpenProcess call failed, GetLastError = %u"),
1290 (unsigned) GetLastError ());
1291 /* We can not debug anything in that case. */
1293 main_thread_id = current_event.dwThreadId;
1294 current_thread = windows_add_thread (
1295 ptid_build (current_event.dwProcessId, 0,
1296 current_event.dwThreadId),
1297 current_event.u.CreateThread.hThread,
1298 current_event.u.CreateThread.lpThreadLocalBase);
1299 return main_thread_id;
1303 windows_resume (struct target_ops *ops,
1304 ptid_t ptid, int step, enum gdb_signal sig)
1306 windows_thread_info *th;
1307 DWORD continue_status = DBG_CONTINUE;
1309 /* A specific PTID means `step only this thread id'. */
1310 int resume_all = ptid_equal (ptid, minus_one_ptid);
1312 /* If we're continuing all threads, it's the current inferior that
1313 should be handled specially. */
1315 ptid = inferior_ptid;
1317 if (sig != GDB_SIGNAL_0)
1319 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1321 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1323 else if (sig == last_sig)
1324 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1327 /* This code does not seem to work, because
1328 the kernel does probably not consider changes in the ExceptionRecord
1329 structure when passing the exception to the inferior.
1330 Note that this seems possible in the exception handler itself. */
1333 for (i = 0; xlate[i].them != -1; i++)
1334 if (xlate[i].us == sig)
1336 current_event.u.Exception.ExceptionRecord.ExceptionCode
1338 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1341 if (continue_status == DBG_CONTINUE)
1343 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1347 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1351 last_sig = GDB_SIGNAL_0;
1353 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1354 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1356 /* Get context for currently selected thread. */
1357 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1362 /* Single step by setting t bit. */
1363 struct regcache *regcache = get_current_regcache ();
1364 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1365 windows_fetch_inferior_registers (ops, regcache,
1366 gdbarch_ps_regnum (gdbarch));
1367 th->context.EFlags |= FLAG_TRACE_BIT;
1370 if (th->context.ContextFlags)
1372 if (debug_registers_changed)
1374 th->context.Dr0 = dr[0];
1375 th->context.Dr1 = dr[1];
1376 th->context.Dr2 = dr[2];
1377 th->context.Dr3 = dr[3];
1378 th->context.Dr6 = DR6_CLEAR_VALUE;
1379 th->context.Dr7 = dr[7];
1381 CHECK (SetThreadContext (th->h, &th->context));
1382 th->context.ContextFlags = 0;
1386 /* Allow continuing with the same signal that interrupted us.
1387 Otherwise complain. */
1390 windows_continue (continue_status, -1, 0);
1392 windows_continue (continue_status, ptid_get_tid (ptid), 0);
1395 /* Ctrl-C handler used when the inferior is not run in the same console. The
1396 handler is in charge of interrupting the inferior using DebugBreakProcess.
1397 Note that this function is not available prior to Windows XP. In this case
1398 we emit a warning. */
1400 ctrl_c_handler (DWORD event_type)
1402 const int attach_flag = current_inferior ()->attach_flag;
1404 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1405 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1408 /* If the inferior and the debugger share the same console, do nothing as
1409 the inferior has also received the Ctrl-C event. */
1410 if (!new_console && !attach_flag)
1413 if (!DebugBreakProcess (current_process_handle))
1414 warning (_("Could not interrupt program. "
1415 "Press Ctrl-c in the program console."));
1417 /* Return true to tell that Ctrl-C has been handled. */
1421 /* Get the next event from the child. Returns a non-zero thread id if the event
1422 requires handling by WFI (or whatever). */
1424 get_windows_debug_event (struct target_ops *ops,
1425 int pid, struct target_waitstatus *ourstatus)
1428 DWORD continue_status, event_code;
1429 windows_thread_info *th;
1430 static windows_thread_info dummy_thread_info;
1431 DWORD thread_id = 0;
1433 last_sig = GDB_SIGNAL_0;
1435 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1439 continue_status = DBG_CONTINUE;
1441 event_code = current_event.dwDebugEventCode;
1442 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1444 have_saved_context = 0;
1448 case CREATE_THREAD_DEBUG_EVENT:
1449 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1450 (unsigned) current_event.dwProcessId,
1451 (unsigned) current_event.dwThreadId,
1452 "CREATE_THREAD_DEBUG_EVENT"));
1453 if (saw_create != 1)
1455 struct inferior *inf;
1456 inf = find_inferior_pid (current_event.dwProcessId);
1457 if (!saw_create && inf->attach_flag)
1459 /* Kludge around a Windows bug where first event is a create
1460 thread event. Caused when attached process does not have
1462 thread_id = fake_create_process ();
1468 /* Record the existence of this thread. */
1469 thread_id = current_event.dwThreadId;
1470 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1471 current_event.dwThreadId),
1472 current_event.u.CreateThread.hThread,
1473 current_event.u.CreateThread.lpThreadLocalBase);
1477 case EXIT_THREAD_DEBUG_EVENT:
1478 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1479 (unsigned) current_event.dwProcessId,
1480 (unsigned) current_event.dwThreadId,
1481 "EXIT_THREAD_DEBUG_EVENT"));
1483 if (current_event.dwThreadId != main_thread_id)
1485 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1486 current_event.dwThreadId),
1487 current_event.u.ExitThread.dwExitCode);
1488 th = &dummy_thread_info;
1492 case CREATE_PROCESS_DEBUG_EVENT:
1493 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1494 (unsigned) current_event.dwProcessId,
1495 (unsigned) current_event.dwThreadId,
1496 "CREATE_PROCESS_DEBUG_EVENT"));
1497 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1498 if (++saw_create != 1)
1501 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1503 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1506 main_thread_id = current_event.dwThreadId;
1507 /* Add the main thread. */
1508 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1509 current_event.dwThreadId),
1510 current_event.u.CreateProcessInfo.hThread,
1511 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1512 thread_id = current_event.dwThreadId;
1515 case EXIT_PROCESS_DEBUG_EVENT:
1516 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1517 (unsigned) current_event.dwProcessId,
1518 (unsigned) current_event.dwThreadId,
1519 "EXIT_PROCESS_DEBUG_EVENT"));
1520 if (!windows_initialization_done)
1522 target_terminal_ours ();
1523 target_mourn_inferior (inferior_ptid);
1524 error (_("During startup program exited with code 0x%x."),
1525 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1527 else if (saw_create == 1)
1529 ourstatus->kind = TARGET_WAITKIND_EXITED;
1530 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1531 thread_id = main_thread_id;
1535 case LOAD_DLL_DEBUG_EVENT:
1536 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1537 (unsigned) current_event.dwProcessId,
1538 (unsigned) current_event.dwThreadId,
1539 "LOAD_DLL_DEBUG_EVENT"));
1540 CloseHandle (current_event.u.LoadDll.hFile);
1541 if (saw_create != 1 || ! windows_initialization_done)
1543 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1544 ourstatus->kind = TARGET_WAITKIND_LOADED;
1545 ourstatus->value.integer = 0;
1546 thread_id = main_thread_id;
1549 case UNLOAD_DLL_DEBUG_EVENT:
1550 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1551 (unsigned) current_event.dwProcessId,
1552 (unsigned) current_event.dwThreadId,
1553 "UNLOAD_DLL_DEBUG_EVENT"));
1554 if (saw_create != 1 || ! windows_initialization_done)
1556 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1557 ourstatus->kind = TARGET_WAITKIND_LOADED;
1558 ourstatus->value.integer = 0;
1559 thread_id = main_thread_id;
1562 case EXCEPTION_DEBUG_EVENT:
1563 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1564 (unsigned) current_event.dwProcessId,
1565 (unsigned) current_event.dwThreadId,
1566 "EXCEPTION_DEBUG_EVENT"));
1567 if (saw_create != 1)
1569 switch (handle_exception (ourstatus))
1571 case HANDLE_EXCEPTION_UNHANDLED:
1573 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1575 case HANDLE_EXCEPTION_HANDLED:
1576 thread_id = current_event.dwThreadId;
1578 case HANDLE_EXCEPTION_IGNORED:
1579 continue_status = DBG_CONTINUE;
1584 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1585 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1586 (unsigned) current_event.dwProcessId,
1587 (unsigned) current_event.dwThreadId,
1588 "OUTPUT_DEBUG_STRING_EVENT"));
1589 if (saw_create != 1)
1591 thread_id = handle_output_debug_string (ourstatus);
1595 if (saw_create != 1)
1597 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1598 (unsigned) current_event.dwProcessId,
1599 (unsigned) current_event.dwThreadId);
1600 printf_unfiltered (" unknown event code %u\n",
1601 (unsigned) current_event.dwDebugEventCode);
1605 if (!thread_id || saw_create != 1)
1607 CHECK (windows_continue (continue_status, -1, 0));
1611 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1613 current_thread = th;
1614 if (!current_thread)
1615 current_thread = thread_rec (thread_id, TRUE);
1622 /* Wait for interesting events to occur in the target process. */
1624 windows_wait (struct target_ops *ops,
1625 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1629 target_terminal_ours ();
1631 /* We loop when we get a non-standard exception rather than return
1632 with a SPURIOUS because resume can try and step or modify things,
1633 which needs a current_thread->h. But some of these exceptions mark
1634 the birth or death of threads, which mean that the current thread
1635 isn't necessarily what you think it is. */
1641 /* If the user presses Ctrl-c while the debugger is waiting
1642 for an event, he expects the debugger to interrupt his program
1643 and to get the prompt back. There are two possible situations:
1645 - The debugger and the program do not share the console, in
1646 which case the Ctrl-c event only reached the debugger.
1647 In that case, the ctrl_c handler will take care of interrupting
1648 the inferior. Note that this case is working starting with
1649 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1652 - The debugger and the program share the same console, in which
1653 case both debugger and inferior will receive the Ctrl-c event.
1654 In that case the ctrl_c handler will ignore the event, as the
1655 Ctrl-c event generated inside the inferior will trigger the
1656 expected debug event.
1658 FIXME: brobecker/2008-05-20: If the inferior receives the
1659 signal first and the delay until GDB receives that signal
1660 is sufficiently long, GDB can sometimes receive the SIGINT
1661 after we have unblocked the CTRL+C handler. This would
1662 lead to the debugger stopping prematurely while handling
1663 the new-thread event that comes with the handling of the SIGINT
1664 inside the inferior, and then stop again immediately when
1665 the user tries to resume the execution in the inferior.
1666 This is a classic race that we should try to fix one day. */
1667 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1668 retval = get_windows_debug_event (ops, pid, ourstatus);
1669 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1672 return ptid_build (current_event.dwProcessId, 0, retval);
1677 if (deprecated_ui_loop_hook != NULL)
1678 detach = deprecated_ui_loop_hook (0);
1681 windows_kill_inferior (ops);
1686 /* Iterate over all DLLs currently mapped by our inferior, and
1687 add them to our list of solibs. */
1690 windows_add_all_dlls (void)
1693 HMODULE dummy_hmodule;
1698 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1699 sizeof (HMODULE), &cb_needed) == 0)
1705 hmodules = (HMODULE *) alloca (cb_needed);
1706 if (EnumProcessModules (current_process_handle, hmodules,
1707 cb_needed, &cb_needed) == 0)
1710 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1714 wchar_t dll_name[__PMAX];
1717 char dll_name[__PMAX];
1720 if (GetModuleInformation (current_process_handle, hmodules[i],
1721 &mi, sizeof (mi)) == 0)
1723 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1724 dll_name, sizeof (dll_name)) == 0)
1727 wcstombs (name, dll_name, __PMAX);
1732 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1733 solib_end = solib_end->next;
1738 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1741 struct inferior *inf;
1742 struct thread_info *tp;
1744 last_sig = GDB_SIGNAL_0;
1746 exception_count = 0;
1747 open_process_used = 0;
1748 debug_registers_changed = 0;
1749 debug_registers_used = 0;
1750 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1753 cygwin_load_start = cygwin_load_end = 0;
1755 current_event.dwProcessId = pid;
1756 memset (¤t_event, 0, sizeof (current_event));
1757 if (!target_is_pushed (ops))
1759 disable_breakpoints_in_shlibs ();
1760 windows_clear_solib ();
1761 clear_proceed_status (0);
1762 init_wait_for_inferior ();
1764 inf = current_inferior ();
1765 inferior_appeared (inf, pid);
1766 inf->attach_flag = attaching;
1768 /* Make the new process the current inferior, so terminal handling
1769 can rely on it. When attaching, we don't know about any thread
1770 id here, but that's OK --- nothing should be referencing the
1771 current thread until we report an event out of windows_wait. */
1772 inferior_ptid = pid_to_ptid (pid);
1774 target_terminal_init ();
1775 target_terminal_inferior ();
1777 windows_initialization_done = 0;
1781 struct target_waitstatus status;
1783 windows_wait (ops, minus_one_ptid, &status, 0);
1785 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1787 if (status.kind != TARGET_WAITKIND_LOADED
1788 && status.kind != TARGET_WAITKIND_SPURIOUS)
1791 windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0);
1794 /* Now that the inferior has been started and all DLLs have been mapped,
1795 we can iterate over all DLLs and load them in.
1797 We avoid doing it any earlier because, on certain versions of Windows,
1798 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1799 we have seen on Windows 8.1 that the ntdll.dll load event does not
1800 include the DLL name, preventing us from creating an associated SO.
1801 A possible explanation is that ntdll.dll might be mapped before
1802 the SO info gets created by the Windows system -- ntdll.dll is
1803 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1804 do not seem to suffer from that problem.
1806 Rather than try to work around this sort of issue, it is much
1807 simpler to just ignore DLL load/unload events during the startup
1808 phase, and then process them all in one batch now. */
1809 windows_add_all_dlls ();
1811 windows_initialization_done = 1;
1815 /* Try to set or remove a user privilege to the current process. Return -1
1816 if that fails, the previous setting of that privilege otherwise.
1818 This code is copied from the Cygwin source code and rearranged to allow
1819 dynamically loading of the needed symbols from advapi32 which is only
1820 available on NT/2K/XP. */
1822 set_process_privilege (const char *privilege, BOOL enable)
1824 HANDLE token_hdl = NULL;
1826 TOKEN_PRIVILEGES new_priv, orig_priv;
1830 if (!OpenProcessToken (GetCurrentProcess (),
1831 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1835 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1838 new_priv.PrivilegeCount = 1;
1839 new_priv.Privileges[0].Luid = restore_priv;
1840 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1842 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1843 sizeof orig_priv, &orig_priv, &size))
1846 /* Disabled, otherwise every `attach' in an unprivileged user session
1847 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1848 windows_attach(). */
1849 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1850 be enabled. GetLastError () returns an correct error code, though. */
1851 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1855 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1859 CloseHandle (token_hdl);
1864 /* Attach to process PID, then initialize for debugging it. */
1866 windows_attach (struct target_ops *ops, const char *args, int from_tty)
1871 pid = parse_pid_to_attach (args);
1873 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1875 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1876 printf_unfiltered ("This can cause attach to "
1877 "fail on Windows NT/2K/XP\n");
1880 windows_init_thread_list ();
1881 ok = DebugActiveProcess (pid);
1887 /* Try fall back to Cygwin pid. */
1888 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1891 ok = DebugActiveProcess (pid);
1896 error (_("Can't attach to process."));
1898 DebugSetProcessKillOnExit (FALSE);
1902 char *exec_file = (char *) get_exec_file (0);
1905 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1906 target_pid_to_str (pid_to_ptid (pid)));
1908 printf_unfiltered ("Attaching to %s\n",
1909 target_pid_to_str (pid_to_ptid (pid)));
1911 gdb_flush (gdb_stdout);
1914 do_initial_windows_stuff (ops, pid, 1);
1915 target_terminal_ours ();
1919 windows_detach (struct target_ops *ops, const char *args, int from_tty)
1923 ptid_t ptid = minus_one_ptid;
1924 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1926 if (!DebugActiveProcessStop (current_event.dwProcessId))
1928 error (_("Can't detach process %u (error %u)"),
1929 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1932 DebugSetProcessKillOnExit (FALSE);
1934 if (detached && from_tty)
1936 const char *exec_file = get_exec_file (0);
1939 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1940 (unsigned) current_event.dwProcessId);
1941 gdb_flush (gdb_stdout);
1944 x86_cleanup_dregs ();
1945 inferior_ptid = null_ptid;
1946 detach_inferior (current_event.dwProcessId);
1948 inf_child_maybe_unpush_target (ops);
1951 /* Try to determine the executable filename.
1953 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1955 Upon success, the filename is stored inside EXE_NAME_RET, and
1956 this function returns nonzero.
1958 Otherwise, this function returns zero and the contents of
1959 EXE_NAME_RET is undefined. */
1962 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1969 if (!EnumProcessModules (current_process_handle, &dh_buf,
1970 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1973 /* We know the executable is always first in the list of modules,
1974 which we just fetched. So no need to fetch more. */
1978 /* Cygwin prefers that the path be in /x/y/z format, so extract
1979 the filename into a temporary buffer first, and then convert it
1980 to POSIX format into the destination buffer. */
1981 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t));
1983 len = GetModuleFileNameEx (current_process_handle,
1984 dh_buf, pathbuf, exe_name_max_len);
1986 error (_("Error getting executable filename: %u."),
1987 (unsigned) GetLastError ());
1988 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
1989 exe_name_max_len) < 0)
1990 error (_("Error converting executable filename to POSIX: %d."), errno);
1993 len = GetModuleFileNameEx (current_process_handle,
1994 dh_buf, exe_name_ret, exe_name_max_len);
1996 error (_("Error getting executable filename: %u."),
1997 (unsigned) GetLastError ());
2000 return 1; /* success */
2003 /* The pid_to_exec_file target_ops method for this platform. */
2006 windows_pid_to_exec_file (struct target_ops *self, int pid)
2008 static char path[__PMAX];
2010 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2012 char procexe[sizeof ("/proc/4294967295/exe")];
2014 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
2015 nchars = readlink (procexe, path, sizeof(path));
2016 if (nchars > 0 && nchars < sizeof (path))
2018 path[nchars] = '\0'; /* Got it */
2023 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2024 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2025 if (!windows_get_exec_module_filename (path, sizeof (path)))
2031 /* Print status information about what we're accessing. */
2034 windows_files_info (struct target_ops *ignore)
2036 struct inferior *inf = current_inferior ();
2038 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2039 inf->attach_flag ? "attached" : "child",
2040 target_pid_to_str (inferior_ptid));
2043 /* Modify CreateProcess parameters for use of a new separate console.
2045 *FLAGS: DWORD parameter for general process creation flags.
2046 *SI: STARTUPINFO structure, for which the console window size and
2047 console buffer size is filled in if GDB is running in a console.
2048 to create the new console.
2049 The size of the used font is not available on all versions of
2050 Windows OS. Furthermore, the current font might not be the default
2051 font, but this is still better than before.
2052 If the windows and buffer sizes are computed,
2053 SI->DWFLAGS is changed so that this information is used
2054 by CreateProcess function. */
2057 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2059 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2060 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2062 if (hconsole != INVALID_HANDLE_VALUE)
2064 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2066 CONSOLE_FONT_INFO cfi;
2068 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2069 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2070 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2071 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2072 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2074 si->dwXSize *= font_size.X;
2078 si->dwYSize *= font_size.Y;
2081 si->dwXCountChars = sbinfo.dwSize.X;
2082 si->dwYCountChars = sbinfo.dwSize.Y;
2083 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2085 *flags |= CREATE_NEW_CONSOLE;
2089 /* Function called by qsort to sort environment strings. */
2092 envvar_cmp (const void *a, const void *b)
2094 const char **p = (const char **) a;
2095 const char **q = (const char **) b;
2096 return strcasecmp (*p, *q);
2102 clear_win32_environment (char **env)
2106 wchar_t *copy = NULL, *equalpos;
2108 for (i = 0; env[i] && *env[i]; i++)
2110 len = mbstowcs (NULL, env[i], 0) + 1;
2111 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2112 mbstowcs (copy, env[i], len);
2113 equalpos = wcschr (copy, L'=');
2116 SetEnvironmentVariableW (copy, NULL);
2124 /* Redirection of inferior I/O streams for native MS-Windows programs.
2125 Unlike on Unix, where this is handled by invoking the inferior via
2126 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2128 The official documentation of the cmd.exe redirection features is here:
2130 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2132 (That page talks about Windows XP, but there's no newer
2133 documentation, so we assume later versions of cmd.exe didn't change
2136 Caveat: the documentation on that page seems to include a few lies.
2137 For example, it describes strange constructs 1<&2 and 2<&1, which
2138 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2139 think the cmd.exe parser of the redirection symbols simply doesn't
2140 care about the < vs > distinction in these cases. Therefore, the
2141 supported features are explicitly documented below.
2143 The emulation below aims at supporting all the valid use cases
2144 supported by cmd.exe, which include:
2146 < FILE redirect standard input from FILE
2147 0< FILE redirect standard input from FILE
2148 <&N redirect standard input from file descriptor N
2149 0<&N redirect standard input from file descriptor N
2150 > FILE redirect standard output to FILE
2151 >> FILE append standard output to FILE
2152 1>> FILE append standard output to FILE
2153 >&N redirect standard output to file descriptor N
2154 1>&N redirect standard output to file descriptor N
2155 >>&N append standard output to file descriptor N
2156 1>>&N append standard output to file descriptor N
2157 2> FILE redirect standard error to FILE
2158 2>> FILE append standard error to FILE
2159 2>&N redirect standard error to file descriptor N
2160 2>>&N append standard error to file descriptor N
2162 Note that using N > 2 in the above construct is supported, but
2163 requires that the corresponding file descriptor be open by some
2164 means elsewhere or outside GDB. Also note that using ">&0" or
2165 "<&2" will generally fail, because the file descriptor redirected
2166 from is normally open in an incompatible mode (e.g., FD 0 is open
2167 for reading only). IOW, use of such tricks is not recommended;
2168 you are on your own.
2170 We do NOT support redirection of file descriptors above 2, as in
2171 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2172 that needs special handling in the startup code that MinGW
2173 doesn't have). Pipes are also not supported.
2175 As for invalid use cases, where the redirection contains some
2176 error, the emulation below will detect that and produce some
2177 error and/or failure. But the behavior in those cases is not
2178 bug-for-bug compatible with what cmd.exe does in those cases.
2179 That's because what cmd.exe does then is not well defined, and
2180 seems to be a side effect of the cmd.exe parsing of the command
2181 line more than anything else. For example, try redirecting to an
2182 invalid file name, as in "> foo:bar".
2184 There are also minor syntactic deviations from what cmd.exe does
2185 in some corner cases. For example, it doesn't support the likes
2186 of "> &foo" to mean redirect to file named literally "&foo"; we
2187 do support that here, because that, too, sounds like some issue
2188 with the cmd.exe parser. Another nicety is that we support
2189 redirection targets that use file names with forward slashes,
2190 something cmd.exe doesn't -- this comes in handy since GDB
2191 file-name completion can be used when typing the command line for
2194 /* Support routines for redirecting standard handles of the inferior. */
2196 /* Parse a single redirection spec, open/duplicate the specified
2197 file/fd, and assign the appropriate value to one of the 3 standard
2198 file descriptors. */
2200 redir_open (const char *redir_string, int *inp, int *out, int *err)
2202 int *fd, ref_fd = -2;
2204 const char *fname = redir_string + 1;
2205 int rc = *redir_string;
2220 fd = (rc == '2') ? err : out;
2221 mode = O_WRONLY | O_CREAT;
2234 if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9')
2236 /* A reference to a file descriptor. */
2238 ref_fd = (int) strtol (fname + 1, &fdtail, 10);
2239 if (fdtail > fname + 1 && *fdtail == '\0')
2241 /* Don't allow redirection when open modes are incompatible. */
2242 if ((ref_fd == 0 && (fd == out || fd == err))
2243 || ((ref_fd == 1 || ref_fd == 2) && fd == inp))
2250 else if (ref_fd == 1)
2252 else if (ref_fd == 2)
2262 fname++; /* skip the separator space */
2263 /* If the descriptor is already open, close it. This allows
2264 multiple specs of redirections for the same stream, which is
2265 somewhat nonsensical, but still valid and supported by cmd.exe.
2266 (But cmd.exe only opens a single file in this case, the one
2267 specified by the last redirection spec on the command line.) */
2272 *fd = _open (fname, mode, _S_IREAD | _S_IWRITE);
2276 else if (ref_fd == -1)
2277 *fd = -1; /* reset to default destination */
2280 *fd = _dup (ref_fd);
2284 /* _open just sets a flag for O_APPEND, which won't be passed to the
2285 inferior, so we need to actually move the file pointer. */
2286 if ((mode & O_APPEND) != 0)
2287 _lseek (*fd, 0L, SEEK_END);
2291 /* Canonicalize a single redirection spec and set up the corresponding
2292 file descriptor as specified. */
2294 redir_set_redirection (const char *s, int *inp, int *out, int *err)
2296 char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */
2298 const char *start = s;
2301 *d++ = *s++; /* copy the 1st character, < or > or a digit */
2302 if ((*start == '>' || *start == '1' || *start == '2')
2306 if (*s == '>' && *start != '>')
2309 else if (*start == '0' && *s == '<')
2311 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2314 while (isspace (*s)) /* skip whitespace before file name */
2316 *d++ = ' '; /* separate file name with a single space */
2319 /* Copy the file name. */
2322 /* Remove quoting characters from the file name in buf[]. */
2323 if (*s == '"') /* could support '..' quoting here */
2327 else if (*s == quote)
2335 else if (*s == '\\')
2337 if (s[1] == '"') /* could support '..' here */
2341 else if (isspace (*s) && !quote)
2345 if (d - buf >= sizeof (buf) - 1)
2347 errno = ENAMETOOLONG;
2353 /* Windows doesn't allow redirection characters in file names, so we
2354 can bail out early if they use them, or if there's no target file
2355 name after the redirection symbol. */
2356 if (d[-1] == '>' || d[-1] == '<')
2361 if (redir_open (buf, inp, out, err) == 0)
2366 /* Parse the command line for redirection specs and prepare the file
2367 descriptors for the 3 standard streams accordingly. */
2369 redirect_inferior_handles (const char *cmd_orig, char *cmd,
2370 int *inp, int *out, int *err)
2372 const char *s = cmd_orig;
2375 bool retval = false;
2377 while (isspace (*s))
2382 if (*s == '"') /* could also support '..' quoting here */
2386 else if (*s == quote)
2389 else if (*s == '\\')
2391 if (s[1] == '"') /* escaped quote char */
2396 /* Process a single redirection candidate. */
2397 if (*s == '<' || *s == '>'
2398 || ((*s == '1' || *s == '2') && s[1] == '>')
2399 || (*s == '0' && s[1] == '<'))
2401 int skip = redir_set_redirection (s, inp, out, err);
2415 #endif /* !__CYGWIN__ */
2417 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2418 EXEC_FILE is the file to run.
2419 ALLARGS is a string containing the arguments to the program.
2420 ENV is the environment vector to pass. Errors reported with error(). */
2423 windows_create_inferior (struct target_ops *ops, const char *exec_file,
2424 const std::string &origallargs, char **in_env,
2429 cygwin_buf_t real_path[__PMAX];
2430 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2432 cygwin_buf_t *toexec;
2433 cygwin_buf_t *cygallargs;
2435 char **old_env = NULL;
2439 int ostdin, ostdout, ostderr;
2440 #else /* !__CYGWIN__ */
2441 char real_path[__PMAX];
2442 char shell[__PMAX]; /* Path to shell */
2444 char *args, *allargs_copy;
2445 size_t args_len, allargs_len;
2446 int fd_inp = -1, fd_out = -1, fd_err = -1;
2447 HANDLE tty = INVALID_HANDLE_VALUE;
2448 HANDLE inf_stdin = INVALID_HANDLE_VALUE;
2449 HANDLE inf_stdout = INVALID_HANDLE_VALUE;
2450 HANDLE inf_stderr = INVALID_HANDLE_VALUE;
2451 bool redirected = false;
2458 #endif /* !__CYGWIN__ */
2459 const char *allargs = origallargs.c_str ();
2460 PROCESS_INFORMATION pi;
2463 const char *inferior_io_terminal = get_inferior_io_terminal ();
2466 error (_("No executable specified, use `target exec'."));
2468 memset (&si, 0, sizeof (si));
2469 si.cb = sizeof (si);
2472 flags |= CREATE_NEW_PROCESS_GROUP;
2475 windows_set_console_info (&si, &flags);
2480 flags |= DEBUG_ONLY_THIS_PROCESS;
2481 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2482 __PMAX * sizeof (cygwin_buf_t)) < 0)
2483 error (_("Error starting executable: %d"), errno);
2486 len = mbstowcs (NULL, allargs, 0) + 1;
2487 if (len == (size_t) -1)
2488 error (_("Error starting executable: %d"), errno);
2489 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2490 mbstowcs (cygallargs, allargs, len);
2491 #else /* !__USEWIDE */
2492 cygallargs = allargs;
2497 sh = getenv ("SHELL");
2500 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2501 error (_("Error starting executable via shell: %d"), errno);
2503 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2504 + mbstowcs (NULL, allargs, 0) + 2;
2505 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2506 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2507 #else /* !__USEWIDE */
2508 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2509 + strlen (allargs) + 2);
2510 cygallargs = (char *) alloca (len);
2511 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2512 #endif /* __USEWIDE */
2514 flags |= DEBUG_PROCESS;
2518 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2519 * sizeof (wchar_t));
2520 wcscpy (args, toexec);
2521 wcscat (args, L" ");
2522 wcscat (args, cygallargs);
2523 #else /* !__USEWIDE */
2524 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2525 strcpy (args, toexec);
2527 strcat (args, cygallargs);
2528 #endif /* !__USEWIDE */
2530 #ifdef CW_CVT_ENV_TO_WINENV
2531 /* First try to create a direct Win32 copy of the POSIX environment. */
2532 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2533 if (w32_env != (PWCHAR) -1)
2534 flags |= CREATE_UNICODE_ENVIRONMENT;
2536 /* If that fails, fall back to old method tweaking GDB's environment. */
2537 #endif /* CW_CVT_ENV_TO_WINENV */
2539 /* Reset all Win32 environment variables to avoid leftover on next run. */
2540 clear_win32_environment (environ);
2541 /* Prepare the environment vars for CreateProcess. */
2544 cygwin_internal (CW_SYNC_WINENV);
2548 if (!inferior_io_terminal)
2549 tty = ostdin = ostdout = ostderr = -1;
2552 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2555 print_sys_errmsg (inferior_io_terminal, errno);
2556 ostdin = ostdout = ostderr = -1;
2569 windows_init_thread_list ();
2570 ret = CreateProcess (0,
2571 args, /* command line */
2572 NULL, /* Security */
2574 TRUE, /* inherit handles */
2575 flags, /* start flags */
2576 w32_env, /* environment */
2577 NULL, /* current directory */
2581 /* Just free the Win32 environment, if it could be created. */
2585 /* Reset all environment variables to avoid leftover on next run. */
2586 clear_win32_environment (in_env);
2587 /* Restore normal GDB environment variables. */
2589 cygwin_internal (CW_SYNC_WINENV);
2602 #else /* !__CYGWIN__ */
2603 allargs_len = strlen (allargs);
2604 allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs);
2605 if (strpbrk (allargs_copy, "<>") != NULL)
2610 redirect_inferior_handles (allargs, allargs_copy,
2611 &fd_inp, &fd_out, &fd_err);
2613 warning (_("Error in redirection: %s."), strerror (errno));
2616 allargs_len = strlen (allargs_copy);
2618 /* If not all the standard streams are redirected by the command
2619 line, use inferior_io_terminal for those which aren't. */
2620 if (inferior_io_terminal
2621 && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0))
2623 SECURITY_ATTRIBUTES sa;
2624 sa.nLength = sizeof(sa);
2625 sa.lpSecurityDescriptor = 0;
2626 sa.bInheritHandle = TRUE;
2627 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2628 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2629 if (tty == INVALID_HANDLE_VALUE)
2630 warning (_("Warning: Failed to open TTY %s, error %#x."),
2631 inferior_io_terminal, (unsigned) GetLastError ());
2633 if (redirected || tty != INVALID_HANDLE_VALUE)
2636 si.hStdInput = (HANDLE) _get_osfhandle (fd_inp);
2637 else if (tty != INVALID_HANDLE_VALUE)
2640 si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
2642 si.hStdOutput = (HANDLE) _get_osfhandle (fd_out);
2643 else if (tty != INVALID_HANDLE_VALUE)
2644 si.hStdOutput = tty;
2646 si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
2648 si.hStdError = (HANDLE) _get_osfhandle (fd_err);
2649 else if (tty != INVALID_HANDLE_VALUE)
2652 si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
2653 si.dwFlags |= STARTF_USESTDHANDLES;
2657 /* Build the command line, a space-separated list of tokens where
2658 the first token is the name of the module to be executed.
2659 To avoid ambiguities introduced by spaces in the module name,
2661 args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2;
2662 args = (char *) alloca (args_len);
2663 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy);
2665 flags |= DEBUG_ONLY_THIS_PROCESS;
2667 /* CreateProcess takes the environment list as a null terminated set of
2668 strings (i.e. two nulls terminate the list). */
2670 /* Get total size for env strings. */
2671 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2672 envlen += strlen (in_env[i]) + 1;
2674 envsize = sizeof (in_env[0]) * (i + 1);
2675 env = (char **) alloca (envsize);
2676 memcpy (env, in_env, envsize);
2677 /* Windows programs expect the environment block to be sorted. */
2678 qsort (env, i, sizeof (char *), envvar_cmp);
2680 w32env = (char *) alloca (envlen + 1);
2682 /* Copy env strings into new buffer. */
2683 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2685 strcpy (temp, env[i]);
2686 temp += strlen (temp) + 1;
2689 /* Final nil string to terminate new env. */
2692 windows_init_thread_list ();
2693 ret = CreateProcessA (0,
2694 args, /* command line */
2695 NULL, /* Security */
2697 TRUE, /* inherit handles */
2698 flags, /* start flags */
2699 w32env, /* environment */
2700 NULL, /* current directory */
2703 if (tty != INVALID_HANDLE_VALUE)
2711 #endif /* !__CYGWIN__ */
2714 error (_("Error creating process %s, (error %u)."),
2715 exec_file, (unsigned) GetLastError ());
2717 CloseHandle (pi.hThread);
2718 CloseHandle (pi.hProcess);
2720 if (useshell && shell[0] != '\0')
2725 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2727 /* windows_continue (DBG_CONTINUE, -1, 0); */
2731 windows_mourn_inferior (struct target_ops *ops)
2733 (void) windows_continue (DBG_CONTINUE, -1, 0);
2734 x86_cleanup_dregs();
2735 if (open_process_used)
2737 CHECK (CloseHandle (current_process_handle));
2738 open_process_used = 0;
2740 inf_child_mourn_inferior (ops);
2743 /* Send a SIGINT to the process group. This acts just like the user typed a
2744 ^C on the controlling terminal. */
2747 windows_interrupt (struct target_ops *self, ptid_t ptid)
2749 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2750 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2751 registers_changed (); /* refresh register state */
2754 /* Helper for windows_xfer_partial that handles memory transfers.
2755 Arguments are like target_xfer_partial. */
2757 static enum target_xfer_status
2758 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2759 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2763 DWORD lasterror = 0;
2765 if (writebuf != NULL)
2767 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2768 pulongest (len), core_addr_to_string (memaddr)));
2769 success = WriteProcessMemory (current_process_handle,
2770 (LPVOID) (uintptr_t) memaddr, writebuf,
2773 lasterror = GetLastError ();
2774 FlushInstructionCache (current_process_handle,
2775 (LPCVOID) (uintptr_t) memaddr, len);
2779 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2780 pulongest (len), core_addr_to_string (memaddr)));
2781 success = ReadProcessMemory (current_process_handle,
2782 (LPCVOID) (uintptr_t) memaddr, readbuf,
2785 lasterror = GetLastError ();
2787 *xfered_len = (ULONGEST) done;
2788 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2789 return TARGET_XFER_OK;
2791 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2795 windows_kill_inferior (struct target_ops *ops)
2797 CHECK (TerminateProcess (current_process_handle, 0));
2801 if (!windows_continue (DBG_CONTINUE, -1, 1))
2803 if (!WaitForDebugEvent (¤t_event, INFINITE))
2805 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2809 target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */
2813 windows_close (struct target_ops *self)
2815 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2816 ptid_get_pid (inferior_ptid)));
2819 /* Convert pid to printable format. */
2821 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2823 static char buf[80];
2825 if (ptid_get_tid (ptid) != 0)
2827 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2828 ptid_get_pid (ptid), ptid_get_tid (ptid));
2832 return normal_pid_to_str (ptid);
2835 static enum target_xfer_status
2836 windows_xfer_shared_libraries (struct target_ops *ops,
2837 enum target_object object, const char *annex,
2838 gdb_byte *readbuf, const gdb_byte *writebuf,
2839 ULONGEST offset, ULONGEST len,
2840 ULONGEST *xfered_len)
2842 struct obstack obstack;
2848 return TARGET_XFER_E_IO;
2850 obstack_init (&obstack);
2851 obstack_grow_str (&obstack, "<library-list>\n");
2852 for (so = solib_start.next; so; so = so->next)
2854 lm_info_windows *li = (lm_info_windows *) so->lm_info;
2856 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2857 (uintptr_t) li->load_addr,
2858 target_gdbarch (), &obstack);
2860 obstack_grow_str0 (&obstack, "</library-list>\n");
2862 buf = (const char *) obstack_finish (&obstack);
2863 len_avail = strlen (buf);
2864 if (offset >= len_avail)
2868 if (len > len_avail - offset)
2869 len = len_avail - offset;
2870 memcpy (readbuf, buf + offset, len);
2873 obstack_free (&obstack, NULL);
2874 *xfered_len = (ULONGEST) len;
2875 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
2878 static enum target_xfer_status
2879 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2880 const char *annex, gdb_byte *readbuf,
2881 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2882 ULONGEST *xfered_len)
2886 case TARGET_OBJECT_MEMORY:
2887 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2889 case TARGET_OBJECT_LIBRARIES:
2890 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2891 writebuf, offset, len, xfered_len);
2894 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2895 readbuf, writebuf, offset, len,
2900 /* Provide thread local base, i.e. Thread Information Block address.
2901 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2904 windows_get_tib_address (struct target_ops *self,
2905 ptid_t ptid, CORE_ADDR *addr)
2907 windows_thread_info *th;
2909 th = thread_rec (ptid_get_tid (ptid), 0);
2914 *addr = th->thread_local_base;
2920 windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2922 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2925 /* Implementation of the to_thread_name method. */
2928 windows_thread_name (struct target_ops *self, struct thread_info *thr)
2930 return thread_rec (ptid_get_tid (thr->ptid), 0)->name;
2933 static struct target_ops *
2934 windows_target (void)
2936 struct target_ops *t = inf_child_target ();
2938 t->to_close = windows_close;
2939 t->to_attach = windows_attach;
2940 t->to_attach_no_wait = 1;
2941 t->to_detach = windows_detach;
2942 t->to_resume = windows_resume;
2943 t->to_wait = windows_wait;
2944 t->to_fetch_registers = windows_fetch_inferior_registers;
2945 t->to_store_registers = windows_store_inferior_registers;
2946 t->to_xfer_partial = windows_xfer_partial;
2947 t->to_files_info = windows_files_info;
2948 t->to_kill = windows_kill_inferior;
2949 t->to_create_inferior = windows_create_inferior;
2950 t->to_mourn_inferior = windows_mourn_inferior;
2951 t->to_thread_alive = windows_thread_alive;
2952 t->to_pid_to_str = windows_pid_to_str;
2953 t->to_interrupt = windows_interrupt;
2954 t->to_pid_to_exec_file = windows_pid_to_exec_file;
2955 t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
2956 t->to_get_tib_address = windows_get_tib_address;
2957 t->to_thread_name = windows_thread_name;
2962 /* -Wmissing-prototypes */
2963 extern initialize_file_ftype _initialize_windows_nat;
2966 _initialize_windows_nat (void)
2968 struct target_ops *t;
2970 t = windows_target ();
2972 x86_use_watchpoints (t);
2974 x86_dr_low.set_control = cygwin_set_dr7;
2975 x86_dr_low.set_addr = cygwin_set_dr;
2976 x86_dr_low.get_addr = cygwin_get_dr;
2977 x86_dr_low.get_status = cygwin_get_dr6;
2978 x86_dr_low.get_control = cygwin_get_dr7;
2980 /* x86_dr_low.debug_register_length field is set by
2981 calling x86_set_debug_register_length function
2982 in processor windows specific native file. */
2987 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
2990 add_com ("signal-event", class_run, signal_event_command, _("\
2991 Signal a crashed process with event ID, to allow its debugging.\n\
2992 This command is needed in support of setting up GDB as JIT debugger on \
2993 MS-Windows. The command should be invoked from the GDB command line using \
2994 the '-ex' command-line option. The ID of the event that blocks the \
2995 crashed process will be supplied by the Windows JIT debugging mechanism."));
2998 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2999 Set use of shell to start subprocess."), _("\
3000 Show use of shell to start subprocess."), NULL,
3002 NULL, /* FIXME: i18n: */
3003 &setlist, &showlist);
3005 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
3006 &cygwin_exceptions, _("\
3007 Break when an exception is detected in the Cygwin DLL itself."), _("\
3008 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
3010 NULL, /* FIXME: i18n: */
3011 &setlist, &showlist);
3014 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
3015 Set creation of new console when creating child process."), _("\
3016 Show creation of new console when creating child process."), NULL,
3018 NULL, /* FIXME: i18n: */
3019 &setlist, &showlist);
3021 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
3022 Set creation of new group when creating child process."), _("\
3023 Show creation of new group when creating child process."), NULL,
3025 NULL, /* FIXME: i18n: */
3026 &setlist, &showlist);
3028 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
3029 Set whether to display execution in child process."), _("\
3030 Show whether to display execution in child process."), NULL,
3032 NULL, /* FIXME: i18n: */
3033 &setlist, &showlist);
3035 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
3036 Set whether to display kernel events in child process."), _("\
3037 Show whether to display kernel events in child process."), NULL,
3039 NULL, /* FIXME: i18n: */
3040 &setlist, &showlist);
3042 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
3043 Set whether to display memory accesses in child process."), _("\
3044 Show whether to display memory accesses in child process."), NULL,
3046 NULL, /* FIXME: i18n: */
3047 &setlist, &showlist);
3049 add_setshow_boolean_cmd ("debugexceptions", class_support,
3050 &debug_exceptions, _("\
3051 Set whether to display kernel exceptions in child process."), _("\
3052 Show whether to display kernel exceptions in child process."), NULL,
3054 NULL, /* FIXME: i18n: */
3055 &setlist, &showlist);
3057 init_w32_command_list ();
3059 add_cmd ("selector", class_info, display_selectors,
3060 _("Display selectors infos."),
3064 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3066 /* Pass the address ADDR to the inferior in the I'th debug register.
3067 Here we just store the address in dr array, the registers will be
3068 actually set up when windows_continue is called. */
3070 cygwin_set_dr (int i, CORE_ADDR addr)
3073 internal_error (__FILE__, __LINE__,
3074 _("Invalid register %d in cygwin_set_dr.\n"), i);
3076 debug_registers_changed = 1;
3077 debug_registers_used = 1;
3080 /* Pass the value VAL to the inferior in the DR7 debug control
3081 register. Here we just store the address in D_REGS, the watchpoint
3082 will be actually set up in windows_wait. */
3084 cygwin_set_dr7 (unsigned long val)
3086 dr[7] = (CORE_ADDR) val;
3087 debug_registers_changed = 1;
3088 debug_registers_used = 1;
3091 /* Get the value of debug register I from the inferior. */
3094 cygwin_get_dr (int i)
3099 /* Get the value of the DR6 debug status register from the inferior.
3100 Here we just return the value stored in dr[6]
3101 by the last call to thread_rec for current_event.dwThreadId id. */
3102 static unsigned long
3103 cygwin_get_dr6 (void)
3105 return (unsigned long) dr[6];
3108 /* Get the value of the DR7 debug status register from the inferior.
3109 Here we just return the value stored in dr[7] by the last call to
3110 thread_rec for current_event.dwThreadId id. */
3112 static unsigned long
3113 cygwin_get_dr7 (void)
3115 return (unsigned long) dr[7];
3118 /* Determine if the thread referenced by "ptid" is alive
3119 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3120 it means that the thread has died. Otherwise it is assumed to be alive. */
3122 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
3126 gdb_assert (ptid_get_tid (ptid) != 0);
3127 tid = ptid_get_tid (ptid);
3129 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
3133 /* -Wmissing-prototypes */
3134 extern initialize_file_ftype _initialize_check_for_gdb_ini;
3137 _initialize_check_for_gdb_ini (void)
3140 if (inhibit_gdbinit)
3143 homedir = getenv ("HOME");
3147 char *oldini = (char *) alloca (strlen (homedir) +
3148 sizeof ("gdb.ini") + 1);
3149 strcpy (oldini, homedir);
3150 p = strchr (oldini, '\0');
3151 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
3153 strcpy (p, "gdb.ini");
3154 if (access (oldini, 0) == 0)
3156 int len = strlen (oldini);
3157 char *newini = (char *) alloca (len + 2);
3159 xsnprintf (newini, len + 2, "%.*s.gdbinit",
3160 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
3161 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
3166 /* Define dummy functions which always return error for the rare cases where
3167 these functions could not be found. */
3169 bad_DebugActiveProcessStop (DWORD w)
3174 bad_DebugBreakProcess (HANDLE w)
3179 bad_DebugSetProcessKillOnExit (BOOL w)
3184 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
3191 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
3197 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
3204 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
3210 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
3216 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
3222 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
3230 /* -Wmissing-prototypes */
3231 extern initialize_file_ftype _initialize_loadable;
3233 /* Load any functions which may not be available in ancient versions
3237 _initialize_loadable (void)
3241 #define GPA(m, func) \
3242 func = (func ## _ftype *) GetProcAddress (m, #func)
3244 hm = LoadLibrary ("kernel32.dll");
3247 GPA (hm, DebugActiveProcessStop);
3248 GPA (hm, DebugBreakProcess);
3249 GPA (hm, DebugSetProcessKillOnExit);
3250 GPA (hm, GetConsoleFontSize);
3251 GPA (hm, DebugActiveProcessStop);
3252 GPA (hm, GetCurrentConsoleFont);
3255 /* Set variables to dummy versions of these processes if the function
3256 wasn't found in kernel32.dll. */
3257 if (!DebugBreakProcess)
3258 DebugBreakProcess = bad_DebugBreakProcess;
3259 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
3261 DebugActiveProcessStop = bad_DebugActiveProcessStop;
3262 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
3264 if (!GetConsoleFontSize)
3265 GetConsoleFontSize = bad_GetConsoleFontSize;
3266 if (!GetCurrentConsoleFont)
3267 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
3269 /* Load optional functions used for retrieving filename information
3270 associated with the currently debugged process or its dlls. */
3271 hm = LoadLibrary ("psapi.dll");
3274 GPA (hm, EnumProcessModules);
3275 GPA (hm, GetModuleInformation);
3276 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *)
3277 GetProcAddress (hm, GetModuleFileNameEx_name);
3280 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
3282 /* Set variables to dummy versions of these processes if the function
3283 wasn't found in psapi.dll. */
3284 EnumProcessModules = bad_EnumProcessModules;
3285 GetModuleInformation = bad_GetModuleInformation;
3286 GetModuleFileNameEx = bad_GetModuleFileNameEx;
3287 /* This will probably fail on Windows 9x/Me. Let the user know
3288 that we're missing some functionality. */
3290 cannot automatically find executable file or library to read symbols.\n\
3291 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3294 hm = LoadLibrary ("advapi32.dll");
3297 GPA (hm, OpenProcessToken);
3298 GPA (hm, LookupPrivilegeValueA);
3299 GPA (hm, AdjustTokenPrivileges);
3300 /* Only need to set one of these since if OpenProcessToken fails nothing
3302 if (!OpenProcessToken || !LookupPrivilegeValueA
3303 || !AdjustTokenPrivileges)
3304 OpenProcessToken = bad_OpenProcessToken;