1 /* Target-vector operations for controlling windows child processes, for GDB.
3 Copyright (C) 1995-2018 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>
48 #include "filenames.h"
52 #include "gdb_obstack.h"
53 #include "gdbthread.h"
59 #include "xml-support.h"
62 #include "i386-tdep.h"
63 #include "i387-tdep.h"
65 #include "windows-tdep.h"
66 #include "windows-nat.h"
68 #include "complaints.h"
69 #include "inf-child.h"
70 #include "gdb_tilde_expand.h"
72 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
73 #define DebugActiveProcessStop dyn_DebugActiveProcessStop
74 #define DebugBreakProcess dyn_DebugBreakProcess
75 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
76 #define EnumProcessModules dyn_EnumProcessModules
77 #define GetModuleInformation dyn_GetModuleInformation
78 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
79 #define OpenProcessToken dyn_OpenProcessToken
80 #define GetConsoleFontSize dyn_GetConsoleFontSize
81 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont
83 typedef BOOL WINAPI (AdjustTokenPrivileges_ftype) (HANDLE, BOOL,
85 DWORD, PTOKEN_PRIVILEGES,
87 static AdjustTokenPrivileges_ftype *AdjustTokenPrivileges;
89 typedef BOOL WINAPI (DebugActiveProcessStop_ftype) (DWORD);
90 static DebugActiveProcessStop_ftype *DebugActiveProcessStop;
92 typedef BOOL WINAPI (DebugBreakProcess_ftype) (HANDLE);
93 static DebugBreakProcess_ftype *DebugBreakProcess;
95 typedef BOOL WINAPI (DebugSetProcessKillOnExit_ftype) (BOOL);
96 static DebugSetProcessKillOnExit_ftype *DebugSetProcessKillOnExit;
98 typedef BOOL WINAPI (EnumProcessModules_ftype) (HANDLE, HMODULE *, DWORD,
100 static EnumProcessModules_ftype *EnumProcessModules;
102 typedef BOOL WINAPI (GetModuleInformation_ftype) (HANDLE, HMODULE,
103 LPMODULEINFO, DWORD);
104 static GetModuleInformation_ftype *GetModuleInformation;
106 typedef BOOL WINAPI (LookupPrivilegeValueA_ftype) (LPCSTR, LPCSTR, PLUID);
107 static LookupPrivilegeValueA_ftype *LookupPrivilegeValueA;
109 typedef BOOL WINAPI (OpenProcessToken_ftype) (HANDLE, DWORD, PHANDLE);
110 static OpenProcessToken_ftype *OpenProcessToken;
112 typedef BOOL WINAPI (GetCurrentConsoleFont_ftype) (HANDLE, BOOL,
113 CONSOLE_FONT_INFO *);
114 static GetCurrentConsoleFont_ftype *GetCurrentConsoleFont;
116 typedef COORD WINAPI (GetConsoleFontSize_ftype) (HANDLE, DWORD);
117 static GetConsoleFontSize_ftype *GetConsoleFontSize;
121 #undef GetModuleFileNameEx
124 # define __PMAX (MAX_PATH + 1)
125 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, LPSTR, DWORD);
126 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
127 # define STARTUPINFO STARTUPINFOA
128 # define CreateProcess CreateProcessA
129 # define GetModuleFileNameEx_name "GetModuleFileNameExA"
130 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
132 # define __PMAX PATH_MAX
133 /* The starting and ending address of the cygwin1.dll text segment. */
134 static CORE_ADDR cygwin_load_start;
135 static CORE_ADDR cygwin_load_end;
137 typedef wchar_t cygwin_buf_t;
138 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE,
140 static GetModuleFileNameEx_ftype *GetModuleFileNameEx;
141 # define STARTUPINFO STARTUPINFOW
142 # define CreateProcess CreateProcessW
143 # define GetModuleFileNameEx_name "GetModuleFileNameExW"
144 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
147 static int have_saved_context; /* True if we've saved context from a
149 static CONTEXT saved_context; /* Containes the saved context from a
152 /* If we're not using the old Cygwin header file set, define the
153 following which never should have been in the generic Win32 API
154 headers in the first place since they were our own invention... */
155 #ifndef _GNU_H_WINDOWS_H
158 FLAG_TRACE_BIT = 0x100,
162 #ifndef CONTEXT_EXTENDED_REGISTERS
163 /* This macro is only defined on ia32. It only makes sense on this target,
164 so define it as zero if not already defined. */
165 #define CONTEXT_EXTENDED_REGISTERS 0
168 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
169 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
170 | CONTEXT_EXTENDED_REGISTERS
172 static uintptr_t dr[8];
173 static int debug_registers_changed;
174 static int debug_registers_used;
176 static int windows_initialization_done;
177 #define DR6_CLEAR_VALUE 0xffff0ff0
179 /* The exception thrown by a program to tell the debugger the name of
180 a thread. The exception record contains an ID of a thread and a
181 name to give it. This exception has no documented name, but MSDN
182 dubs it "MS_VC_EXCEPTION" in one code example. */
183 #define MS_VC_EXCEPTION 0x406d1388
187 HANDLE_EXCEPTION_UNHANDLED = 0,
188 HANDLE_EXCEPTION_HANDLED,
189 HANDLE_EXCEPTION_IGNORED
190 } handle_exception_result;
192 /* The string sent by cygwin when it processes a signal.
193 FIXME: This should be in a cygwin include file. */
194 #ifndef _CYGWIN_SIGNAL_STRING
195 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
198 #define CHECK(x) check (x, __FILE__,__LINE__)
199 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
200 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
201 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
202 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
204 static void windows_interrupt (struct target_ops *self);
205 static int windows_thread_alive (struct target_ops *, ptid_t);
206 static void windows_kill_inferior (struct target_ops *);
208 static void cygwin_set_dr (int i, CORE_ADDR addr);
209 static void cygwin_set_dr7 (unsigned long val);
210 static CORE_ADDR cygwin_get_dr (int i);
211 static unsigned long cygwin_get_dr6 (void);
212 static unsigned long cygwin_get_dr7 (void);
214 static enum gdb_signal last_sig = GDB_SIGNAL_0;
215 /* Set if a signal was received from the debugged process. */
217 /* Thread information structure used to track information that is
218 not available in gdb's thread structure. */
219 typedef struct windows_thread_info_struct
221 struct windows_thread_info_struct *next;
224 CORE_ADDR thread_local_base;
233 static windows_thread_info thread_head;
235 /* The process and thread handles for the above context. */
237 static DEBUG_EVENT current_event; /* The current debug event from
239 static HANDLE current_process_handle; /* Currently executing process */
240 static windows_thread_info *current_thread; /* Info on currently selected thread */
241 static DWORD main_thread_id; /* Thread ID of the main thread */
243 /* Counts of things. */
244 static int exception_count = 0;
245 static int event_count = 0;
246 static int saw_create;
247 static int open_process_used = 0;
250 static int new_console = 0;
252 static int cygwin_exceptions = 0;
254 static int new_group = 1;
255 static int debug_exec = 0; /* show execution */
256 static int debug_events = 0; /* show events from kernel */
257 static int debug_memory = 0; /* show target memory accesses */
258 static int debug_exceptions = 0; /* show target exceptions */
259 static int useshell = 0; /* use shell for subprocesses */
261 /* This vector maps GDB's idea of a register's number into an offset
262 in the windows exception context vector.
264 It also contains the bit mask needed to load the register in question.
266 The contents of this table can only be computed by the units
267 that provide CPU-specific support for Windows native debugging.
268 These units should set the table by calling
269 windows_set_context_register_offsets.
271 One day we could read a reg, we could inspect the context we
272 already have loaded, if it doesn't have the bit set that we need,
273 we read that set of registers in using GetThreadContext. If the
274 context already contains what we need, we just unpack it. Then to
275 write a register, first we have to ensure that the context contains
276 the other regs of the group, and then we copy the info in and set
279 static const int *mappings;
281 /* The function to use in order to determine whether a register is
282 a segment register or not. */
283 static segment_register_p_ftype *segment_register_p;
285 /* This vector maps the target's idea of an exception (extracted
286 from the DEBUG_EVENT structure) to GDB's idea. */
288 struct xlate_exception
294 static const struct xlate_exception
297 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
298 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
299 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
300 {DBG_CONTROL_C, GDB_SIGNAL_INT},
301 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
302 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
303 {-1, GDB_SIGNAL_UNKNOWN}};
305 /* Set the MAPPINGS static global to OFFSETS.
306 See the description of MAPPINGS for more details. */
309 windows_set_context_register_offsets (const int *offsets)
314 /* See windows-nat.h. */
317 windows_set_segment_register_p (segment_register_p_ftype *fun)
319 segment_register_p = fun;
323 check (BOOL ok, const char *file, int line)
326 printf_filtered ("error return %s:%d was %u\n", file, line,
327 (unsigned) GetLastError ());
330 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
331 then also retrieve the context for this thread. If GET_CONTEXT is
332 negative, then don't suspend the thread. */
333 static windows_thread_info *
334 thread_rec (DWORD id, int get_context)
336 windows_thread_info *th;
338 for (th = &thread_head; (th = th->next) != NULL;)
341 if (!th->suspended && get_context)
343 if (get_context > 0 && id != current_event.dwThreadId)
345 if (SuspendThread (th->h) == (DWORD) -1)
347 DWORD err = GetLastError ();
349 /* We get Access Denied (5) when trying to suspend
350 threads that Windows started on behalf of the
351 debuggee, usually when those threads are just
353 We can get Invalid Handle (6) if the main thread
355 if (err != ERROR_INVALID_HANDLE
356 && err != ERROR_ACCESS_DENIED)
357 warning (_("SuspendThread (tid=0x%x) failed."
359 (unsigned) id, (unsigned) err);
365 else if (get_context < 0)
367 th->reload_context = 1;
375 /* Add a thread to the thread list. */
376 static windows_thread_info *
377 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
379 windows_thread_info *th;
382 gdb_assert (ptid_get_tid (ptid) != 0);
384 id = ptid_get_tid (ptid);
386 if ((th = thread_rec (id, FALSE)))
389 th = XCNEW (windows_thread_info);
392 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
393 th->next = thread_head.next;
394 thread_head.next = th;
396 /* Set the debug registers for the new thread if they are used. */
397 if (debug_registers_used)
399 /* Only change the value of the debug registers. */
400 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
401 CHECK (GetThreadContext (th->h, &th->context));
402 th->context.Dr0 = dr[0];
403 th->context.Dr1 = dr[1];
404 th->context.Dr2 = dr[2];
405 th->context.Dr3 = dr[3];
406 th->context.Dr6 = DR6_CLEAR_VALUE;
407 th->context.Dr7 = dr[7];
408 CHECK (SetThreadContext (th->h, &th->context));
409 th->context.ContextFlags = 0;
414 /* Clear out any old thread list and reinitialize it to a
417 windows_init_thread_list (void)
419 windows_thread_info *th = &thread_head;
421 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
423 while (th->next != NULL)
425 windows_thread_info *here = th->next;
426 th->next = here->next;
429 thread_head.next = NULL;
432 /* Delete a thread from the list of threads. */
434 windows_delete_thread (ptid_t ptid, DWORD exit_code)
436 windows_thread_info *th;
439 gdb_assert (ptid_get_tid (ptid) != 0);
441 id = ptid_get_tid (ptid);
444 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
445 else if (print_thread_events && id != main_thread_id)
446 printf_unfiltered (_("[%s exited with code %u]\n"),
447 target_pid_to_str (ptid), (unsigned) exit_code);
448 delete_thread (ptid);
450 for (th = &thread_head;
451 th->next != NULL && th->next->id != id;
455 if (th->next != NULL)
457 windows_thread_info *here = th->next;
458 th->next = here->next;
465 do_windows_fetch_inferior_registers (struct regcache *regcache,
466 windows_thread_info *th, int r)
468 char *context_offset = ((char *) &th->context) + mappings[r];
469 struct gdbarch *gdbarch = regcache->arch ();
470 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
473 if (th->reload_context)
476 if (have_saved_context)
478 /* Lie about where the program actually is stopped since
479 cygwin has informed us that we should consider the signal
480 to have occurred at another location which is stored in
482 memcpy (&th->context, &saved_context,
483 __COPY_CONTEXT_SIZE);
484 have_saved_context = 0;
489 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
490 CHECK (GetThreadContext (th->h, &th->context));
491 /* Copy dr values from that thread.
492 But only if there were not modified since last stop.
494 if (!debug_registers_changed)
496 dr[0] = th->context.Dr0;
497 dr[1] = th->context.Dr1;
498 dr[2] = th->context.Dr2;
499 dr[3] = th->context.Dr3;
500 dr[6] = th->context.Dr6;
501 dr[7] = th->context.Dr7;
504 th->reload_context = 0;
507 if (r == I387_FISEG_REGNUM (tdep))
509 l = *((long *) context_offset) & 0xffff;
510 regcache_raw_supply (regcache, r, (char *) &l);
512 else if (r == I387_FOP_REGNUM (tdep))
514 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
515 regcache_raw_supply (regcache, r, (char *) &l);
517 else if (segment_register_p (r))
519 /* GDB treats segment registers as 32bit registers, but they are
520 in fact only 16 bits long. Make sure we do not read extra
521 bits from our source buffer. */
522 l = *((long *) context_offset) & 0xffff;
523 regcache_raw_supply (regcache, r, (char *) &l);
526 regcache_raw_supply (regcache, r, context_offset);
529 for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
530 do_windows_fetch_inferior_registers (regcache, th, r);
535 windows_fetch_inferior_registers (struct target_ops *ops,
536 struct regcache *regcache, int r)
538 DWORD pid = ptid_get_tid (regcache_get_ptid (regcache));
539 windows_thread_info *th = thread_rec (pid, TRUE);
541 /* Check if TH exists. Windows sometimes uses a non-existent
542 thread id in its events. */
544 do_windows_fetch_inferior_registers (regcache, th, r);
548 do_windows_store_inferior_registers (const struct regcache *regcache,
549 windows_thread_info *th, int r)
552 regcache_raw_collect (regcache, r,
553 ((char *) &th->context) + mappings[r]);
556 for (r = 0; r < gdbarch_num_regs (regcache->arch ()); r++)
557 do_windows_store_inferior_registers (regcache, th, r);
561 /* Store a new register value into the context of the thread tied to
564 windows_store_inferior_registers (struct target_ops *ops,
565 struct regcache *regcache, int r)
567 DWORD pid = ptid_get_tid (regcache_get_ptid (regcache));
568 windows_thread_info *th = thread_rec (pid, TRUE);
570 /* Check if TH exists. Windows sometimes uses a non-existent
571 thread id in its events. */
573 do_windows_store_inferior_registers (regcache, th, r);
576 /* Encapsulate the information required in a call to
577 symbol_file_add_args. */
578 struct safe_symbol_file_add_args
582 struct section_addr_info *addrs;
585 struct ui_file *err, *out;
589 /* Maintain a linked list of "so" information. */
590 struct lm_info_windows : public lm_info_base
592 LPVOID load_addr = 0;
595 static struct so_list solib_start, *solib_end;
597 static struct so_list *
598 windows_make_so (const char *name, LPVOID load_addr)
605 WIN32_FIND_DATA w32_fd;
606 HANDLE h = FindFirstFile(name, &w32_fd);
608 if (h == INVALID_HANDLE_VALUE)
614 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
616 p = strrchr (buf, '\\');
619 SetCurrentDirectory (buf);
620 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
621 SetCurrentDirectory (cwd);
624 if (strcasecmp (buf, "ntdll.dll") == 0)
626 GetSystemDirectory (buf, sizeof (buf));
627 strcat (buf, "\\ntdll.dll");
630 cygwin_buf_t buf[__PMAX];
633 if (access (name, F_OK) != 0)
635 if (strcasecmp (name, "ntdll.dll") == 0)
638 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
639 wcscat (buf, L"\\ntdll.dll");
643 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
644 strcat (buf, "\\ntdll.dll");
649 so = XCNEW (struct so_list);
650 lm_info_windows *li = new lm_info_windows;
652 li->load_addr = load_addr;
653 strcpy (so->so_original_name, name);
655 strcpy (so->so_name, buf);
658 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
659 SO_NAME_MAX_PATH_SIZE);
662 char *rname = realpath (name, NULL);
663 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
665 strcpy (so->so_name, rname);
669 error (_("dll path too long"));
671 /* Record cygwin1.dll .text start/end. */
672 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
673 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
675 asection *text = NULL;
678 gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386", -1));
683 if (bfd_check_format (abfd.get (), bfd_object))
684 text = bfd_get_section_by_name (abfd.get (), ".text");
689 /* The symbols in a dll are offset by 0x1000, which is the
690 offset from 0 of the first byte in an image - because of the
691 file header and the section alignment. */
692 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
694 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd.get (),
703 get_image_name (HANDLE h, void *address, int unicode)
706 static char buf[__PMAX];
708 static char buf[(2 * __PMAX) + 1];
710 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
716 /* Attempt to read the name of the dll that was detected.
717 This is documented to work only when actively debugging
718 a program. It will not work for attached processes. */
722 /* See if we could read the address of a string, and that the
723 address isn't null. */
724 if (!ReadProcessMemory (h, address, &address_ptr,
725 sizeof (address_ptr), &done)
726 || done != sizeof (address_ptr) || !address_ptr)
729 /* Find the length of the string. */
730 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
731 && (b[0] != 0 || b[size - 1] != 0) && done == size)
735 ReadProcessMemory (h, address_ptr, buf, len, &done);
738 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
739 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
742 wcstombs (buf, unicode_address, __PMAX);
744 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
752 /* Handle a DLL load event, and return 1.
754 This function assumes that this event did not occur during inferior
755 initialization, where their event info may be incomplete (see
756 do_initial_windows_stuff and windows_add_all_dlls for more info
757 on how we handle DLL loading during that phase). */
762 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
765 /* Try getting the DLL name via the lpImageName field of the event.
766 Note that Microsoft documents this fields as strictly optional,
767 in the sense that it might be NULL. And the first DLL event in
768 particular is explicitly documented as "likely not pass[ed]"
769 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
770 dll_name = get_image_name (current_process_handle,
771 event->lpImageName, event->fUnicode);
775 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
776 solib_end = solib_end->next;
778 lm_info_windows *li = (lm_info_windows *) solib_end->lm_info;
780 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
781 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). */
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));
836 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
840 catch_errors (void (*func) ())
846 CATCH (ex, RETURN_MASK_ALL)
848 exception_print (gdb_stderr, ex);
853 /* Clear list of loaded DLLs. */
855 windows_clear_solib (void)
857 solib_start.next = NULL;
858 solib_end = &solib_start;
862 signal_event_command (const char *args, int from_tty)
864 uintptr_t event_id = 0;
865 char *endargs = NULL;
868 error (_("signal-event requires an argument (integer event id)"));
870 event_id = strtoumax (args, &endargs, 10);
872 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) ||
873 ((HANDLE) event_id == INVALID_HANDLE_VALUE))
874 error (_("Failed to convert `%s' to event id"), args);
876 SetEvent ((HANDLE) event_id);
877 CloseHandle ((HANDLE) event_id);
880 /* Handle DEBUG_STRING output from child process.
881 Cygwin prepends its messages with a "cygwin:". Interpret this as
882 a Cygwin signal. Otherwise just print the string as a warning. */
884 handle_output_debug_string (struct target_waitstatus *ourstatus)
889 if (!target_read_string
890 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
894 else if (!startswith (s, _CYGWIN_SIGNAL_STRING))
897 if (!startswith (s, "cYg"))
900 char *p = strchr (s, '\0');
902 if (p > s && *--p == '\n')
910 /* Got a cygwin signal marker. A cygwin signal is followed by
911 the signal number itself and then optionally followed by the
912 thread id and address to saved context within the DLL. If
913 these are supplied, then the given thread is assumed to have
914 issued the signal and the context from the thread is assumed
915 to be stored at the given address in the inferior. Tell gdb
916 to treat this like a real signal. */
918 int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
919 gdb_signal gotasig = gdb_signal_from_host (sig);
921 ourstatus->value.sig = gotasig;
927 ourstatus->kind = TARGET_WAITKIND_STOPPED;
928 retval = strtoul (p, &p, 0);
930 retval = main_thread_id;
931 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
932 && ReadProcessMemory (current_process_handle, x,
934 __COPY_CONTEXT_SIZE, &n)
935 && n == __COPY_CONTEXT_SIZE)
936 have_saved_context = 1;
947 display_selector (HANDLE thread, DWORD sel)
950 if (GetThreadSelectorEntry (thread, sel, &info))
953 printf_filtered ("0x%03x: ", (unsigned) sel);
954 if (!info.HighWord.Bits.Pres)
956 puts_filtered ("Segment not present\n");
959 base = (info.HighWord.Bits.BaseHi << 24) +
960 (info.HighWord.Bits.BaseMid << 16)
962 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
963 if (info.HighWord.Bits.Granularity)
964 limit = (limit << 12) | 0xfff;
965 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
966 if (info.HighWord.Bits.Default_Big)
967 puts_filtered(" 32-bit ");
969 puts_filtered(" 16-bit ");
970 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
973 puts_filtered ("Data (Read-Only, Exp-up");
976 puts_filtered ("Data (Read/Write, Exp-up");
979 puts_filtered ("Unused segment (");
982 puts_filtered ("Data (Read/Write, Exp-down");
985 puts_filtered ("Code (Exec-Only, N.Conf");
988 puts_filtered ("Code (Exec/Read, N.Conf");
991 puts_filtered ("Code (Exec-Only, Conf");
994 puts_filtered ("Code (Exec/Read, Conf");
997 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
999 if ((info.HighWord.Bits.Type & 0x1) == 0)
1000 puts_filtered(", N.Acc");
1001 puts_filtered (")\n");
1002 if ((info.HighWord.Bits.Type & 0x10) == 0)
1003 puts_filtered("System selector ");
1004 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1005 if (info.HighWord.Bits.Granularity)
1006 puts_filtered ("Page granular.\n");
1008 puts_filtered ("Byte granular.\n");
1013 DWORD err = GetLastError ();
1014 if (err == ERROR_NOT_SUPPORTED)
1015 printf_filtered ("Function not supported\n");
1017 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1023 display_selectors (const char * args, int from_tty)
1025 if (!current_thread)
1027 puts_filtered ("Impossible to display selectors now.\n");
1033 puts_filtered ("Selector $cs\n");
1034 display_selector (current_thread->h,
1035 current_thread->context.SegCs);
1036 puts_filtered ("Selector $ds\n");
1037 display_selector (current_thread->h,
1038 current_thread->context.SegDs);
1039 puts_filtered ("Selector $es\n");
1040 display_selector (current_thread->h,
1041 current_thread->context.SegEs);
1042 puts_filtered ("Selector $ss\n");
1043 display_selector (current_thread->h,
1044 current_thread->context.SegSs);
1045 puts_filtered ("Selector $fs\n");
1046 display_selector (current_thread->h,
1047 current_thread->context.SegFs);
1048 puts_filtered ("Selector $gs\n");
1049 display_selector (current_thread->h,
1050 current_thread->context.SegGs);
1055 sel = parse_and_eval_long (args);
1056 printf_filtered ("Selector \"%s\"\n",args);
1057 display_selector (current_thread->h, sel);
1061 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1062 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1063 host_address_to_string (\
1064 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1066 static handle_exception_result
1067 handle_exception (struct target_waitstatus *ourstatus)
1069 EXCEPTION_RECORD *rec = ¤t_event.u.Exception.ExceptionRecord;
1070 DWORD code = rec->ExceptionCode;
1071 handle_exception_result result = HANDLE_EXCEPTION_HANDLED;
1073 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1075 /* Record the context of the current thread. */
1076 thread_rec (current_event.dwThreadId, -1);
1080 case EXCEPTION_ACCESS_VIOLATION:
1081 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1082 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1085 /* See if the access violation happened within the cygwin DLL
1086 itself. Cygwin uses a kind of exception handling to deal
1087 with passed-in invalid addresses. gdb should not treat
1088 these as real SEGVs since they will be silently handled by
1089 cygwin. A real SEGV will (theoretically) be caught by
1090 cygwin later in the process and will be sent as a
1091 cygwin-specific-signal. So, ignore SEGVs if they show up
1092 within the text segment of the DLL itself. */
1094 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress;
1096 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1097 && addr < cygwin_load_end))
1098 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1099 && startswith (fn, "KERNEL32!IsBad")))
1100 return HANDLE_EXCEPTION_UNHANDLED;
1104 case STATUS_STACK_OVERFLOW:
1105 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1106 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1108 case STATUS_FLOAT_DENORMAL_OPERAND:
1109 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1110 ourstatus->value.sig = GDB_SIGNAL_FPE;
1112 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1113 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1114 ourstatus->value.sig = GDB_SIGNAL_FPE;
1116 case STATUS_FLOAT_INEXACT_RESULT:
1117 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1118 ourstatus->value.sig = GDB_SIGNAL_FPE;
1120 case STATUS_FLOAT_INVALID_OPERATION:
1121 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1122 ourstatus->value.sig = GDB_SIGNAL_FPE;
1124 case STATUS_FLOAT_OVERFLOW:
1125 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1126 ourstatus->value.sig = GDB_SIGNAL_FPE;
1128 case STATUS_FLOAT_STACK_CHECK:
1129 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1130 ourstatus->value.sig = GDB_SIGNAL_FPE;
1132 case STATUS_FLOAT_UNDERFLOW:
1133 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1134 ourstatus->value.sig = GDB_SIGNAL_FPE;
1136 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1137 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1138 ourstatus->value.sig = GDB_SIGNAL_FPE;
1140 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1141 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1142 ourstatus->value.sig = GDB_SIGNAL_FPE;
1144 case STATUS_INTEGER_OVERFLOW:
1145 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1146 ourstatus->value.sig = GDB_SIGNAL_FPE;
1148 case EXCEPTION_BREAKPOINT:
1149 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1150 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1153 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1154 ourstatus->value.sig = GDB_SIGNAL_INT;
1156 case DBG_CONTROL_BREAK:
1157 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1158 ourstatus->value.sig = GDB_SIGNAL_INT;
1160 case EXCEPTION_SINGLE_STEP:
1161 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1162 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1164 case EXCEPTION_ILLEGAL_INSTRUCTION:
1165 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1166 ourstatus->value.sig = GDB_SIGNAL_ILL;
1168 case EXCEPTION_PRIV_INSTRUCTION:
1169 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1170 ourstatus->value.sig = GDB_SIGNAL_ILL;
1172 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1173 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1174 ourstatus->value.sig = GDB_SIGNAL_ILL;
1176 case MS_VC_EXCEPTION:
1177 if (rec->NumberParameters >= 3
1178 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
1180 DWORD named_thread_id;
1181 windows_thread_info *named_thread;
1182 CORE_ADDR thread_name_target;
1184 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1186 thread_name_target = rec->ExceptionInformation[1];
1187 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]);
1189 if (named_thread_id == (DWORD) -1)
1190 named_thread_id = current_event.dwThreadId;
1192 named_thread = thread_rec (named_thread_id, 0);
1193 if (named_thread != NULL)
1195 int thread_name_len;
1198 thread_name_len = target_read_string (thread_name_target,
1199 &thread_name, 1025, NULL);
1200 if (thread_name_len > 0)
1202 thread_name[thread_name_len - 1] = '\0';
1203 xfree (named_thread->name);
1204 named_thread->name = thread_name;
1207 xfree (thread_name);
1209 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1210 result = HANDLE_EXCEPTION_IGNORED;
1213 /* treat improperly formed exception as unknown, fallthrough */
1215 /* Treat unhandled first chance exceptions specially. */
1216 if (current_event.u.Exception.dwFirstChance)
1217 return HANDLE_EXCEPTION_UNHANDLED;
1218 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1219 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1220 host_address_to_string (
1221 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1222 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1226 last_sig = ourstatus->value.sig;
1230 /* Resume thread specified by ID, or all artificially suspended
1231 threads, if we are continuing execution. KILLED non-zero means we
1232 have killed the inferior, so we should ignore weird errors due to
1233 threads shutting down. */
1235 windows_continue (DWORD continue_status, int id, int killed)
1238 windows_thread_info *th;
1241 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1242 (unsigned) current_event.dwProcessId,
1243 (unsigned) current_event.dwThreadId,
1244 continue_status == DBG_CONTINUE ?
1245 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1247 for (th = &thread_head; (th = th->next) != NULL;)
1248 if ((id == -1 || id == (int) th->id)
1251 if (debug_registers_changed)
1253 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1254 th->context.Dr0 = dr[0];
1255 th->context.Dr1 = dr[1];
1256 th->context.Dr2 = dr[2];
1257 th->context.Dr3 = dr[3];
1258 th->context.Dr6 = DR6_CLEAR_VALUE;
1259 th->context.Dr7 = dr[7];
1261 if (th->context.ContextFlags)
1265 if (GetExitCodeThread (th->h, &ec)
1266 && ec == STILL_ACTIVE)
1268 BOOL status = SetThreadContext (th->h, &th->context);
1273 th->context.ContextFlags = 0;
1275 if (th->suspended > 0)
1276 (void) ResumeThread (th->h);
1280 res = ContinueDebugEvent (current_event.dwProcessId,
1281 current_event.dwThreadId,
1285 error (_("Failed to resume program execution"
1286 " (ContinueDebugEvent failed, error %u)"),
1287 (unsigned int) GetLastError ());
1289 debug_registers_changed = 0;
1293 /* Called in pathological case where Windows fails to send a
1294 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1296 fake_create_process (void)
1298 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1299 current_event.dwProcessId);
1300 if (current_process_handle != NULL)
1301 open_process_used = 1;
1304 error (_("OpenProcess call failed, GetLastError = %u"),
1305 (unsigned) GetLastError ());
1306 /* We can not debug anything in that case. */
1308 main_thread_id = current_event.dwThreadId;
1309 current_thread = windows_add_thread (
1310 ptid_build (current_event.dwProcessId, 0,
1311 current_event.dwThreadId),
1312 current_event.u.CreateThread.hThread,
1313 current_event.u.CreateThread.lpThreadLocalBase);
1314 return main_thread_id;
1318 windows_resume (struct target_ops *ops,
1319 ptid_t ptid, int step, enum gdb_signal sig)
1321 windows_thread_info *th;
1322 DWORD continue_status = DBG_CONTINUE;
1324 /* A specific PTID means `step only this thread id'. */
1325 int resume_all = ptid_equal (ptid, minus_one_ptid);
1327 /* If we're continuing all threads, it's the current inferior that
1328 should be handled specially. */
1330 ptid = inferior_ptid;
1332 if (sig != GDB_SIGNAL_0)
1334 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1336 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1338 else if (sig == last_sig)
1339 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1342 /* This code does not seem to work, because
1343 the kernel does probably not consider changes in the ExceptionRecord
1344 structure when passing the exception to the inferior.
1345 Note that this seems possible in the exception handler itself. */
1348 for (i = 0; xlate[i].them != -1; i++)
1349 if (xlate[i].us == sig)
1351 current_event.u.Exception.ExceptionRecord.ExceptionCode
1353 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1356 if (continue_status == DBG_CONTINUE)
1358 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1362 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1366 last_sig = GDB_SIGNAL_0;
1368 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1369 ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1371 /* Get context for currently selected thread. */
1372 th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1377 /* Single step by setting t bit. */
1378 struct regcache *regcache = get_current_regcache ();
1379 struct gdbarch *gdbarch = regcache->arch ();
1380 windows_fetch_inferior_registers (ops, regcache,
1381 gdbarch_ps_regnum (gdbarch));
1382 th->context.EFlags |= FLAG_TRACE_BIT;
1385 if (th->context.ContextFlags)
1387 if (debug_registers_changed)
1389 th->context.Dr0 = dr[0];
1390 th->context.Dr1 = dr[1];
1391 th->context.Dr2 = dr[2];
1392 th->context.Dr3 = dr[3];
1393 th->context.Dr6 = DR6_CLEAR_VALUE;
1394 th->context.Dr7 = dr[7];
1396 CHECK (SetThreadContext (th->h, &th->context));
1397 th->context.ContextFlags = 0;
1401 /* Allow continuing with the same signal that interrupted us.
1402 Otherwise complain. */
1405 windows_continue (continue_status, -1, 0);
1407 windows_continue (continue_status, ptid_get_tid (ptid), 0);
1410 /* Ctrl-C handler used when the inferior is not run in the same console. The
1411 handler is in charge of interrupting the inferior using DebugBreakProcess.
1412 Note that this function is not available prior to Windows XP. In this case
1413 we emit a warning. */
1415 ctrl_c_handler (DWORD event_type)
1417 const int attach_flag = current_inferior ()->attach_flag;
1419 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1420 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1423 /* If the inferior and the debugger share the same console, do nothing as
1424 the inferior has also received the Ctrl-C event. */
1425 if (!new_console && !attach_flag)
1428 if (!DebugBreakProcess (current_process_handle))
1429 warning (_("Could not interrupt program. "
1430 "Press Ctrl-c in the program console."));
1432 /* Return true to tell that Ctrl-C has been handled. */
1436 /* Get the next event from the child. Returns a non-zero thread id if the event
1437 requires handling by WFI (or whatever). */
1439 get_windows_debug_event (struct target_ops *ops,
1440 int pid, struct target_waitstatus *ourstatus)
1443 DWORD continue_status, event_code;
1444 windows_thread_info *th;
1445 static windows_thread_info dummy_thread_info;
1446 DWORD thread_id = 0;
1448 last_sig = GDB_SIGNAL_0;
1450 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1454 continue_status = DBG_CONTINUE;
1456 event_code = current_event.dwDebugEventCode;
1457 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1459 have_saved_context = 0;
1463 case CREATE_THREAD_DEBUG_EVENT:
1464 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1465 (unsigned) current_event.dwProcessId,
1466 (unsigned) current_event.dwThreadId,
1467 "CREATE_THREAD_DEBUG_EVENT"));
1468 if (saw_create != 1)
1470 struct inferior *inf;
1471 inf = find_inferior_pid (current_event.dwProcessId);
1472 if (!saw_create && inf->attach_flag)
1474 /* Kludge around a Windows bug where first event is a create
1475 thread event. Caused when attached process does not have
1477 thread_id = fake_create_process ();
1483 /* Record the existence of this thread. */
1484 thread_id = current_event.dwThreadId;
1485 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1486 current_event.dwThreadId),
1487 current_event.u.CreateThread.hThread,
1488 current_event.u.CreateThread.lpThreadLocalBase);
1492 case EXIT_THREAD_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 "EXIT_THREAD_DEBUG_EVENT"));
1498 if (current_event.dwThreadId != main_thread_id)
1500 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1501 current_event.dwThreadId),
1502 current_event.u.ExitThread.dwExitCode);
1503 th = &dummy_thread_info;
1507 case CREATE_PROCESS_DEBUG_EVENT:
1508 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1509 (unsigned) current_event.dwProcessId,
1510 (unsigned) current_event.dwThreadId,
1511 "CREATE_PROCESS_DEBUG_EVENT"));
1512 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1513 if (++saw_create != 1)
1516 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1518 windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1521 main_thread_id = current_event.dwThreadId;
1522 /* Add the main thread. */
1523 th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1524 current_event.dwThreadId),
1525 current_event.u.CreateProcessInfo.hThread,
1526 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1527 thread_id = current_event.dwThreadId;
1530 case EXIT_PROCESS_DEBUG_EVENT:
1531 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1532 (unsigned) current_event.dwProcessId,
1533 (unsigned) current_event.dwThreadId,
1534 "EXIT_PROCESS_DEBUG_EVENT"));
1535 if (!windows_initialization_done)
1537 target_terminal::ours ();
1538 target_mourn_inferior (inferior_ptid);
1539 error (_("During startup program exited with code 0x%x."),
1540 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1542 else if (saw_create == 1)
1544 ourstatus->kind = TARGET_WAITKIND_EXITED;
1545 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1546 thread_id = main_thread_id;
1550 case LOAD_DLL_DEBUG_EVENT:
1551 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1552 (unsigned) current_event.dwProcessId,
1553 (unsigned) current_event.dwThreadId,
1554 "LOAD_DLL_DEBUG_EVENT"));
1555 CloseHandle (current_event.u.LoadDll.hFile);
1556 if (saw_create != 1 || ! windows_initialization_done)
1558 catch_errors (handle_load_dll);
1559 ourstatus->kind = TARGET_WAITKIND_LOADED;
1560 ourstatus->value.integer = 0;
1561 thread_id = main_thread_id;
1564 case UNLOAD_DLL_DEBUG_EVENT:
1565 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1566 (unsigned) current_event.dwProcessId,
1567 (unsigned) current_event.dwThreadId,
1568 "UNLOAD_DLL_DEBUG_EVENT"));
1569 if (saw_create != 1 || ! windows_initialization_done)
1571 catch_errors (handle_unload_dll);
1572 ourstatus->kind = TARGET_WAITKIND_LOADED;
1573 ourstatus->value.integer = 0;
1574 thread_id = main_thread_id;
1577 case EXCEPTION_DEBUG_EVENT:
1578 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1579 (unsigned) current_event.dwProcessId,
1580 (unsigned) current_event.dwThreadId,
1581 "EXCEPTION_DEBUG_EVENT"));
1582 if (saw_create != 1)
1584 switch (handle_exception (ourstatus))
1586 case HANDLE_EXCEPTION_UNHANDLED:
1588 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1590 case HANDLE_EXCEPTION_HANDLED:
1591 thread_id = current_event.dwThreadId;
1593 case HANDLE_EXCEPTION_IGNORED:
1594 continue_status = DBG_CONTINUE;
1599 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1600 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1601 (unsigned) current_event.dwProcessId,
1602 (unsigned) current_event.dwThreadId,
1603 "OUTPUT_DEBUG_STRING_EVENT"));
1604 if (saw_create != 1)
1606 thread_id = handle_output_debug_string (ourstatus);
1610 if (saw_create != 1)
1612 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1613 (unsigned) current_event.dwProcessId,
1614 (unsigned) current_event.dwThreadId);
1615 printf_unfiltered (" unknown event code %u\n",
1616 (unsigned) current_event.dwDebugEventCode);
1620 if (!thread_id || saw_create != 1)
1622 CHECK (windows_continue (continue_status, -1, 0));
1626 inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1628 current_thread = th;
1629 if (!current_thread)
1630 current_thread = thread_rec (thread_id, TRUE);
1637 /* Wait for interesting events to occur in the target process. */
1639 windows_wait (struct target_ops *ops,
1640 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
1644 target_terminal::ours ();
1646 /* We loop when we get a non-standard exception rather than return
1647 with a SPURIOUS because resume can try and step or modify things,
1648 which needs a current_thread->h. But some of these exceptions mark
1649 the birth or death of threads, which mean that the current thread
1650 isn't necessarily what you think it is. */
1656 /* If the user presses Ctrl-c while the debugger is waiting
1657 for an event, he expects the debugger to interrupt his program
1658 and to get the prompt back. There are two possible situations:
1660 - The debugger and the program do not share the console, in
1661 which case the Ctrl-c event only reached the debugger.
1662 In that case, the ctrl_c handler will take care of interrupting
1663 the inferior. Note that this case is working starting with
1664 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1667 - The debugger and the program share the same console, in which
1668 case both debugger and inferior will receive the Ctrl-c event.
1669 In that case the ctrl_c handler will ignore the event, as the
1670 Ctrl-c event generated inside the inferior will trigger the
1671 expected debug event.
1673 FIXME: brobecker/2008-05-20: If the inferior receives the
1674 signal first and the delay until GDB receives that signal
1675 is sufficiently long, GDB can sometimes receive the SIGINT
1676 after we have unblocked the CTRL+C handler. This would
1677 lead to the debugger stopping prematurely while handling
1678 the new-thread event that comes with the handling of the SIGINT
1679 inside the inferior, and then stop again immediately when
1680 the user tries to resume the execution in the inferior.
1681 This is a classic race that we should try to fix one day. */
1682 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1683 retval = get_windows_debug_event (ops, pid, ourstatus);
1684 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1687 return ptid_build (current_event.dwProcessId, 0, retval);
1692 if (deprecated_ui_loop_hook != NULL)
1693 detach = deprecated_ui_loop_hook (0);
1696 windows_kill_inferior (ops);
1701 /* Iterate over all DLLs currently mapped by our inferior, and
1702 add them to our list of solibs. */
1705 windows_add_all_dlls (void)
1708 HMODULE dummy_hmodule;
1713 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1714 sizeof (HMODULE), &cb_needed) == 0)
1720 hmodules = (HMODULE *) alloca (cb_needed);
1721 if (EnumProcessModules (current_process_handle, hmodules,
1722 cb_needed, &cb_needed) == 0)
1725 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1729 wchar_t dll_name[__PMAX];
1732 char dll_name[__PMAX];
1735 if (GetModuleInformation (current_process_handle, hmodules[i],
1736 &mi, sizeof (mi)) == 0)
1738 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1739 dll_name, sizeof (dll_name)) == 0)
1742 wcstombs (name, dll_name, __PMAX);
1747 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1748 solib_end = solib_end->next;
1753 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1756 struct inferior *inf;
1757 struct thread_info *tp;
1759 last_sig = GDB_SIGNAL_0;
1761 exception_count = 0;
1762 open_process_used = 0;
1763 debug_registers_changed = 0;
1764 debug_registers_used = 0;
1765 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1768 cygwin_load_start = cygwin_load_end = 0;
1770 current_event.dwProcessId = pid;
1771 memset (¤t_event, 0, sizeof (current_event));
1772 if (!target_is_pushed (ops))
1774 disable_breakpoints_in_shlibs ();
1775 windows_clear_solib ();
1776 clear_proceed_status (0);
1777 init_wait_for_inferior ();
1779 inf = current_inferior ();
1780 inferior_appeared (inf, pid);
1781 inf->attach_flag = attaching;
1783 /* Make the new process the current inferior, so terminal handling
1784 can rely on it. When attaching, we don't know about any thread
1785 id here, but that's OK --- nothing should be referencing the
1786 current thread until we report an event out of windows_wait. */
1787 inferior_ptid = pid_to_ptid (pid);
1789 target_terminal::init ();
1790 target_terminal::inferior ();
1792 windows_initialization_done = 0;
1796 struct target_waitstatus status;
1798 windows_wait (ops, minus_one_ptid, &status, 0);
1800 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1802 if (status.kind != TARGET_WAITKIND_LOADED
1803 && status.kind != TARGET_WAITKIND_SPURIOUS)
1806 windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0);
1809 /* Now that the inferior has been started and all DLLs have been mapped,
1810 we can iterate over all DLLs and load them in.
1812 We avoid doing it any earlier because, on certain versions of Windows,
1813 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1814 we have seen on Windows 8.1 that the ntdll.dll load event does not
1815 include the DLL name, preventing us from creating an associated SO.
1816 A possible explanation is that ntdll.dll might be mapped before
1817 the SO info gets created by the Windows system -- ntdll.dll is
1818 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1819 do not seem to suffer from that problem.
1821 Rather than try to work around this sort of issue, it is much
1822 simpler to just ignore DLL load/unload events during the startup
1823 phase, and then process them all in one batch now. */
1824 windows_add_all_dlls ();
1826 windows_initialization_done = 1;
1830 /* Try to set or remove a user privilege to the current process. Return -1
1831 if that fails, the previous setting of that privilege otherwise.
1833 This code is copied from the Cygwin source code and rearranged to allow
1834 dynamically loading of the needed symbols from advapi32 which is only
1835 available on NT/2K/XP. */
1837 set_process_privilege (const char *privilege, BOOL enable)
1839 HANDLE token_hdl = NULL;
1841 TOKEN_PRIVILEGES new_priv, orig_priv;
1845 if (!OpenProcessToken (GetCurrentProcess (),
1846 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1850 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1853 new_priv.PrivilegeCount = 1;
1854 new_priv.Privileges[0].Luid = restore_priv;
1855 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1857 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1858 sizeof orig_priv, &orig_priv, &size))
1861 /* Disabled, otherwise every `attach' in an unprivileged user session
1862 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1863 windows_attach(). */
1864 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1865 be enabled. GetLastError () returns an correct error code, though. */
1866 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1870 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1874 CloseHandle (token_hdl);
1879 /* Attach to process PID, then initialize for debugging it. */
1881 windows_attach (struct target_ops *ops, const char *args, int from_tty)
1886 pid = parse_pid_to_attach (args);
1888 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1890 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1891 printf_unfiltered ("This can cause attach to "
1892 "fail on Windows NT/2K/XP\n");
1895 windows_init_thread_list ();
1896 ok = DebugActiveProcess (pid);
1902 /* Try fall back to Cygwin pid. */
1903 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1906 ok = DebugActiveProcess (pid);
1911 error (_("Can't attach to process."));
1913 DebugSetProcessKillOnExit (FALSE);
1917 char *exec_file = (char *) get_exec_file (0);
1920 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1921 target_pid_to_str (pid_to_ptid (pid)));
1923 printf_unfiltered ("Attaching to %s\n",
1924 target_pid_to_str (pid_to_ptid (pid)));
1926 gdb_flush (gdb_stdout);
1929 do_initial_windows_stuff (ops, pid, 1);
1930 target_terminal::ours ();
1934 windows_detach (struct target_ops *ops, inferior *inf, int from_tty)
1938 ptid_t ptid = minus_one_ptid;
1939 windows_resume (ops, ptid, 0, GDB_SIGNAL_0);
1941 if (!DebugActiveProcessStop (current_event.dwProcessId))
1943 error (_("Can't detach process %u (error %u)"),
1944 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
1947 DebugSetProcessKillOnExit (FALSE);
1949 if (detached && from_tty)
1951 const char *exec_file = get_exec_file (0);
1954 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
1955 (unsigned) current_event.dwProcessId);
1956 gdb_flush (gdb_stdout);
1959 x86_cleanup_dregs ();
1960 inferior_ptid = null_ptid;
1961 detach_inferior (current_event.dwProcessId);
1963 inf_child_maybe_unpush_target (ops);
1966 /* Try to determine the executable filename.
1968 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
1970 Upon success, the filename is stored inside EXE_NAME_RET, and
1971 this function returns nonzero.
1973 Otherwise, this function returns zero and the contents of
1974 EXE_NAME_RET is undefined. */
1977 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
1984 if (!EnumProcessModules (current_process_handle, &dh_buf,
1985 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
1988 /* We know the executable is always first in the list of modules,
1989 which we just fetched. So no need to fetch more. */
1993 /* Cygwin prefers that the path be in /x/y/z format, so extract
1994 the filename into a temporary buffer first, and then convert it
1995 to POSIX format into the destination buffer. */
1996 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t));
1998 len = GetModuleFileNameEx (current_process_handle,
1999 dh_buf, pathbuf, exe_name_max_len);
2001 error (_("Error getting executable filename: %u."),
2002 (unsigned) GetLastError ());
2003 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
2004 exe_name_max_len) < 0)
2005 error (_("Error converting executable filename to POSIX: %d."), errno);
2008 len = GetModuleFileNameEx (current_process_handle,
2009 dh_buf, exe_name_ret, exe_name_max_len);
2011 error (_("Error getting executable filename: %u."),
2012 (unsigned) GetLastError ());
2015 return 1; /* success */
2018 /* The pid_to_exec_file target_ops method for this platform. */
2021 windows_pid_to_exec_file (struct target_ops *self, int pid)
2023 static char path[__PMAX];
2025 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2027 char procexe[sizeof ("/proc/4294967295/exe")];
2029 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
2030 nchars = readlink (procexe, path, sizeof(path));
2031 if (nchars > 0 && nchars < sizeof (path))
2033 path[nchars] = '\0'; /* Got it */
2038 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2039 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2040 if (!windows_get_exec_module_filename (path, sizeof (path)))
2046 /* Print status information about what we're accessing. */
2049 windows_files_info (struct target_ops *ignore)
2051 struct inferior *inf = current_inferior ();
2053 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2054 inf->attach_flag ? "attached" : "child",
2055 target_pid_to_str (inferior_ptid));
2058 /* Modify CreateProcess parameters for use of a new separate console.
2060 *FLAGS: DWORD parameter for general process creation flags.
2061 *SI: STARTUPINFO structure, for which the console window size and
2062 console buffer size is filled in if GDB is running in a console.
2063 to create the new console.
2064 The size of the used font is not available on all versions of
2065 Windows OS. Furthermore, the current font might not be the default
2066 font, but this is still better than before.
2067 If the windows and buffer sizes are computed,
2068 SI->DWFLAGS is changed so that this information is used
2069 by CreateProcess function. */
2072 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2074 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2075 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2077 if (hconsole != INVALID_HANDLE_VALUE)
2079 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2081 CONSOLE_FONT_INFO cfi;
2083 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2084 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2085 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2086 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2087 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2089 si->dwXSize *= font_size.X;
2093 si->dwYSize *= font_size.Y;
2096 si->dwXCountChars = sbinfo.dwSize.X;
2097 si->dwYCountChars = sbinfo.dwSize.Y;
2098 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2100 *flags |= CREATE_NEW_CONSOLE;
2104 /* Function called by qsort to sort environment strings. */
2107 envvar_cmp (const void *a, const void *b)
2109 const char **p = (const char **) a;
2110 const char **q = (const char **) b;
2111 return strcasecmp (*p, *q);
2117 clear_win32_environment (char **env)
2121 wchar_t *copy = NULL, *equalpos;
2123 for (i = 0; env[i] && *env[i]; i++)
2125 len = mbstowcs (NULL, env[i], 0) + 1;
2126 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2127 mbstowcs (copy, env[i], len);
2128 equalpos = wcschr (copy, L'=');
2131 SetEnvironmentVariableW (copy, NULL);
2139 /* Redirection of inferior I/O streams for native MS-Windows programs.
2140 Unlike on Unix, where this is handled by invoking the inferior via
2141 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2143 The official documentation of the cmd.exe redirection features is here:
2145 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2147 (That page talks about Windows XP, but there's no newer
2148 documentation, so we assume later versions of cmd.exe didn't change
2151 Caveat: the documentation on that page seems to include a few lies.
2152 For example, it describes strange constructs 1<&2 and 2<&1, which
2153 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2154 think the cmd.exe parser of the redirection symbols simply doesn't
2155 care about the < vs > distinction in these cases. Therefore, the
2156 supported features are explicitly documented below.
2158 The emulation below aims at supporting all the valid use cases
2159 supported by cmd.exe, which include:
2161 < FILE redirect standard input from FILE
2162 0< FILE redirect standard input from FILE
2163 <&N redirect standard input from file descriptor N
2164 0<&N redirect standard input from file descriptor N
2165 > FILE redirect standard output to FILE
2166 >> FILE append standard output to FILE
2167 1>> FILE append standard output to FILE
2168 >&N redirect standard output to file descriptor N
2169 1>&N redirect standard output to file descriptor N
2170 >>&N append standard output to file descriptor N
2171 1>>&N append standard output to file descriptor N
2172 2> FILE redirect standard error to FILE
2173 2>> FILE append standard error to FILE
2174 2>&N redirect standard error to file descriptor N
2175 2>>&N append standard error to file descriptor N
2177 Note that using N > 2 in the above construct is supported, but
2178 requires that the corresponding file descriptor be open by some
2179 means elsewhere or outside GDB. Also note that using ">&0" or
2180 "<&2" will generally fail, because the file descriptor redirected
2181 from is normally open in an incompatible mode (e.g., FD 0 is open
2182 for reading only). IOW, use of such tricks is not recommended;
2183 you are on your own.
2185 We do NOT support redirection of file descriptors above 2, as in
2186 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2187 that needs special handling in the startup code that MinGW
2188 doesn't have). Pipes are also not supported.
2190 As for invalid use cases, where the redirection contains some
2191 error, the emulation below will detect that and produce some
2192 error and/or failure. But the behavior in those cases is not
2193 bug-for-bug compatible with what cmd.exe does in those cases.
2194 That's because what cmd.exe does then is not well defined, and
2195 seems to be a side effect of the cmd.exe parsing of the command
2196 line more than anything else. For example, try redirecting to an
2197 invalid file name, as in "> foo:bar".
2199 There are also minor syntactic deviations from what cmd.exe does
2200 in some corner cases. For example, it doesn't support the likes
2201 of "> &foo" to mean redirect to file named literally "&foo"; we
2202 do support that here, because that, too, sounds like some issue
2203 with the cmd.exe parser. Another nicety is that we support
2204 redirection targets that use file names with forward slashes,
2205 something cmd.exe doesn't -- this comes in handy since GDB
2206 file-name completion can be used when typing the command line for
2209 /* Support routines for redirecting standard handles of the inferior. */
2211 /* Parse a single redirection spec, open/duplicate the specified
2212 file/fd, and assign the appropriate value to one of the 3 standard
2213 file descriptors. */
2215 redir_open (const char *redir_string, int *inp, int *out, int *err)
2217 int *fd, ref_fd = -2;
2219 const char *fname = redir_string + 1;
2220 int rc = *redir_string;
2235 fd = (rc == '2') ? err : out;
2236 mode = O_WRONLY | O_CREAT;
2249 if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9')
2251 /* A reference to a file descriptor. */
2253 ref_fd = (int) strtol (fname + 1, &fdtail, 10);
2254 if (fdtail > fname + 1 && *fdtail == '\0')
2256 /* Don't allow redirection when open modes are incompatible. */
2257 if ((ref_fd == 0 && (fd == out || fd == err))
2258 || ((ref_fd == 1 || ref_fd == 2) && fd == inp))
2265 else if (ref_fd == 1)
2267 else if (ref_fd == 2)
2277 fname++; /* skip the separator space */
2278 /* If the descriptor is already open, close it. This allows
2279 multiple specs of redirections for the same stream, which is
2280 somewhat nonsensical, but still valid and supported by cmd.exe.
2281 (But cmd.exe only opens a single file in this case, the one
2282 specified by the last redirection spec on the command line.) */
2287 *fd = _open (fname, mode, _S_IREAD | _S_IWRITE);
2291 else if (ref_fd == -1)
2292 *fd = -1; /* reset to default destination */
2295 *fd = _dup (ref_fd);
2299 /* _open just sets a flag for O_APPEND, which won't be passed to the
2300 inferior, so we need to actually move the file pointer. */
2301 if ((mode & O_APPEND) != 0)
2302 _lseek (*fd, 0L, SEEK_END);
2306 /* Canonicalize a single redirection spec and set up the corresponding
2307 file descriptor as specified. */
2309 redir_set_redirection (const char *s, int *inp, int *out, int *err)
2311 char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */
2313 const char *start = s;
2316 *d++ = *s++; /* copy the 1st character, < or > or a digit */
2317 if ((*start == '>' || *start == '1' || *start == '2')
2321 if (*s == '>' && *start != '>')
2324 else if (*start == '0' && *s == '<')
2326 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2329 while (isspace (*s)) /* skip whitespace before file name */
2331 *d++ = ' '; /* separate file name with a single space */
2334 /* Copy the file name. */
2337 /* Remove quoting characters from the file name in buf[]. */
2338 if (*s == '"') /* could support '..' quoting here */
2342 else if (*s == quote)
2350 else if (*s == '\\')
2352 if (s[1] == '"') /* could support '..' here */
2356 else if (isspace (*s) && !quote)
2360 if (d - buf >= sizeof (buf) - 1)
2362 errno = ENAMETOOLONG;
2368 /* Windows doesn't allow redirection characters in file names, so we
2369 can bail out early if they use them, or if there's no target file
2370 name after the redirection symbol. */
2371 if (d[-1] == '>' || d[-1] == '<')
2376 if (redir_open (buf, inp, out, err) == 0)
2381 /* Parse the command line for redirection specs and prepare the file
2382 descriptors for the 3 standard streams accordingly. */
2384 redirect_inferior_handles (const char *cmd_orig, char *cmd,
2385 int *inp, int *out, int *err)
2387 const char *s = cmd_orig;
2390 bool retval = false;
2392 while (isspace (*s))
2397 if (*s == '"') /* could also support '..' quoting here */
2401 else if (*s == quote)
2404 else if (*s == '\\')
2406 if (s[1] == '"') /* escaped quote char */
2411 /* Process a single redirection candidate. */
2412 if (*s == '<' || *s == '>'
2413 || ((*s == '1' || *s == '2') && s[1] == '>')
2414 || (*s == '0' && s[1] == '<'))
2416 int skip = redir_set_redirection (s, inp, out, err);
2430 #endif /* !__CYGWIN__ */
2432 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2433 EXEC_FILE is the file to run.
2434 ALLARGS is a string containing the arguments to the program.
2435 ENV is the environment vector to pass. Errors reported with error(). */
2438 windows_create_inferior (struct target_ops *ops, const char *exec_file,
2439 const std::string &origallargs, char **in_env,
2444 cygwin_buf_t real_path[__PMAX];
2445 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2446 cygwin_buf_t infcwd[__PMAX];
2448 cygwin_buf_t *toexec;
2449 cygwin_buf_t *cygallargs;
2451 char **old_env = NULL;
2455 int ostdin, ostdout, ostderr;
2456 #else /* !__CYGWIN__ */
2457 char real_path[__PMAX];
2458 char shell[__PMAX]; /* Path to shell */
2460 char *args, *allargs_copy;
2461 size_t args_len, allargs_len;
2462 int fd_inp = -1, fd_out = -1, fd_err = -1;
2463 HANDLE tty = INVALID_HANDLE_VALUE;
2464 HANDLE inf_stdin = INVALID_HANDLE_VALUE;
2465 HANDLE inf_stdout = INVALID_HANDLE_VALUE;
2466 HANDLE inf_stderr = INVALID_HANDLE_VALUE;
2467 bool redirected = false;
2474 #endif /* !__CYGWIN__ */
2475 const char *allargs = origallargs.c_str ();
2476 PROCESS_INFORMATION pi;
2479 const char *inferior_io_terminal = get_inferior_io_terminal ();
2482 error (_("No executable specified, use `target exec'."));
2484 const char *inferior_cwd = get_inferior_cwd ();
2485 std::string expanded_infcwd;
2486 if (inferior_cwd != NULL)
2488 expanded_infcwd = gdb_tilde_expand (inferior_cwd);
2489 /* Mirror slashes on inferior's cwd. */
2490 std::replace (expanded_infcwd.begin (), expanded_infcwd.end (),
2492 inferior_cwd = expanded_infcwd.c_str ();
2495 memset (&si, 0, sizeof (si));
2496 si.cb = sizeof (si);
2499 flags |= CREATE_NEW_PROCESS_GROUP;
2502 windows_set_console_info (&si, &flags);
2507 flags |= DEBUG_ONLY_THIS_PROCESS;
2508 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2509 __PMAX * sizeof (cygwin_buf_t)) < 0)
2510 error (_("Error starting executable: %d"), errno);
2513 len = mbstowcs (NULL, allargs, 0) + 1;
2514 if (len == (size_t) -1)
2515 error (_("Error starting executable: %d"), errno);
2516 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2517 mbstowcs (cygallargs, allargs, len);
2518 #else /* !__USEWIDE */
2519 cygallargs = allargs;
2524 sh = getenv ("SHELL");
2527 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2528 error (_("Error starting executable via shell: %d"), errno);
2530 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2531 + mbstowcs (NULL, allargs, 0) + 2;
2532 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2533 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2534 #else /* !__USEWIDE */
2535 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2536 + strlen (allargs) + 2);
2537 cygallargs = (char *) alloca (len);
2538 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2539 #endif /* __USEWIDE */
2541 flags |= DEBUG_PROCESS;
2544 if (inferior_cwd != NULL
2545 && cygwin_conv_path (CCP_POSIX_TO_WIN_W, inferior_cwd,
2546 infcwd, strlen (inferior_cwd)) < 0)
2547 error (_("Error converting inferior cwd: %d"), errno);
2550 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2551 * sizeof (wchar_t));
2552 wcscpy (args, toexec);
2553 wcscat (args, L" ");
2554 wcscat (args, cygallargs);
2555 #else /* !__USEWIDE */
2556 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2557 strcpy (args, toexec);
2559 strcat (args, cygallargs);
2560 #endif /* !__USEWIDE */
2562 #ifdef CW_CVT_ENV_TO_WINENV
2563 /* First try to create a direct Win32 copy of the POSIX environment. */
2564 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2565 if (w32_env != (PWCHAR) -1)
2566 flags |= CREATE_UNICODE_ENVIRONMENT;
2568 /* If that fails, fall back to old method tweaking GDB's environment. */
2569 #endif /* CW_CVT_ENV_TO_WINENV */
2571 /* Reset all Win32 environment variables to avoid leftover on next run. */
2572 clear_win32_environment (environ);
2573 /* Prepare the environment vars for CreateProcess. */
2576 cygwin_internal (CW_SYNC_WINENV);
2580 if (!inferior_io_terminal)
2581 tty = ostdin = ostdout = ostderr = -1;
2584 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2587 print_sys_errmsg (inferior_io_terminal, errno);
2588 ostdin = ostdout = ostderr = -1;
2601 windows_init_thread_list ();
2602 ret = CreateProcess (0,
2603 args, /* command line */
2604 NULL, /* Security */
2606 TRUE, /* inherit handles */
2607 flags, /* start flags */
2608 w32_env, /* environment */
2609 inferior_cwd != NULL ? infcwd : NULL, /* current
2614 /* Just free the Win32 environment, if it could be created. */
2618 /* Reset all environment variables to avoid leftover on next run. */
2619 clear_win32_environment (in_env);
2620 /* Restore normal GDB environment variables. */
2622 cygwin_internal (CW_SYNC_WINENV);
2635 #else /* !__CYGWIN__ */
2636 allargs_len = strlen (allargs);
2637 allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs);
2638 if (strpbrk (allargs_copy, "<>") != NULL)
2643 redirect_inferior_handles (allargs, allargs_copy,
2644 &fd_inp, &fd_out, &fd_err);
2646 warning (_("Error in redirection: %s."), strerror (errno));
2649 allargs_len = strlen (allargs_copy);
2651 /* If not all the standard streams are redirected by the command
2652 line, use inferior_io_terminal for those which aren't. */
2653 if (inferior_io_terminal
2654 && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0))
2656 SECURITY_ATTRIBUTES sa;
2657 sa.nLength = sizeof(sa);
2658 sa.lpSecurityDescriptor = 0;
2659 sa.bInheritHandle = TRUE;
2660 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2661 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2662 if (tty == INVALID_HANDLE_VALUE)
2663 warning (_("Warning: Failed to open TTY %s, error %#x."),
2664 inferior_io_terminal, (unsigned) GetLastError ());
2666 if (redirected || tty != INVALID_HANDLE_VALUE)
2669 si.hStdInput = (HANDLE) _get_osfhandle (fd_inp);
2670 else if (tty != INVALID_HANDLE_VALUE)
2673 si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
2675 si.hStdOutput = (HANDLE) _get_osfhandle (fd_out);
2676 else if (tty != INVALID_HANDLE_VALUE)
2677 si.hStdOutput = tty;
2679 si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
2681 si.hStdError = (HANDLE) _get_osfhandle (fd_err);
2682 else if (tty != INVALID_HANDLE_VALUE)
2685 si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
2686 si.dwFlags |= STARTF_USESTDHANDLES;
2690 /* Build the command line, a space-separated list of tokens where
2691 the first token is the name of the module to be executed.
2692 To avoid ambiguities introduced by spaces in the module name,
2694 args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2;
2695 args = (char *) alloca (args_len);
2696 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy);
2698 flags |= DEBUG_ONLY_THIS_PROCESS;
2700 /* CreateProcess takes the environment list as a null terminated set of
2701 strings (i.e. two nulls terminate the list). */
2703 /* Get total size for env strings. */
2704 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2705 envlen += strlen (in_env[i]) + 1;
2707 envsize = sizeof (in_env[0]) * (i + 1);
2708 env = (char **) alloca (envsize);
2709 memcpy (env, in_env, envsize);
2710 /* Windows programs expect the environment block to be sorted. */
2711 qsort (env, i, sizeof (char *), envvar_cmp);
2713 w32env = (char *) alloca (envlen + 1);
2715 /* Copy env strings into new buffer. */
2716 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2718 strcpy (temp, env[i]);
2719 temp += strlen (temp) + 1;
2722 /* Final nil string to terminate new env. */
2725 windows_init_thread_list ();
2726 ret = CreateProcessA (0,
2727 args, /* command line */
2728 NULL, /* Security */
2730 TRUE, /* inherit handles */
2731 flags, /* start flags */
2732 w32env, /* environment */
2733 inferior_cwd, /* current directory */
2736 if (tty != INVALID_HANDLE_VALUE)
2744 #endif /* !__CYGWIN__ */
2747 error (_("Error creating process %s, (error %u)."),
2748 exec_file, (unsigned) GetLastError ());
2750 CloseHandle (pi.hThread);
2751 CloseHandle (pi.hProcess);
2753 if (useshell && shell[0] != '\0')
2758 do_initial_windows_stuff (ops, pi.dwProcessId, 0);
2760 /* windows_continue (DBG_CONTINUE, -1, 0); */
2764 windows_mourn_inferior (struct target_ops *ops)
2766 (void) windows_continue (DBG_CONTINUE, -1, 0);
2767 x86_cleanup_dregs();
2768 if (open_process_used)
2770 CHECK (CloseHandle (current_process_handle));
2771 open_process_used = 0;
2773 inf_child_mourn_inferior (ops);
2776 /* Send a SIGINT to the process group. This acts just like the user typed a
2777 ^C on the controlling terminal. */
2780 windows_interrupt (struct target_ops *self)
2782 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2783 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2784 registers_changed (); /* refresh register state */
2787 /* Helper for windows_xfer_partial that handles memory transfers.
2788 Arguments are like target_xfer_partial. */
2790 static enum target_xfer_status
2791 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2792 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2796 DWORD lasterror = 0;
2798 if (writebuf != NULL)
2800 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2801 pulongest (len), core_addr_to_string (memaddr)));
2802 success = WriteProcessMemory (current_process_handle,
2803 (LPVOID) (uintptr_t) memaddr, writebuf,
2806 lasterror = GetLastError ();
2807 FlushInstructionCache (current_process_handle,
2808 (LPCVOID) (uintptr_t) memaddr, len);
2812 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2813 pulongest (len), core_addr_to_string (memaddr)));
2814 success = ReadProcessMemory (current_process_handle,
2815 (LPCVOID) (uintptr_t) memaddr, readbuf,
2818 lasterror = GetLastError ();
2820 *xfered_len = (ULONGEST) done;
2821 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2822 return TARGET_XFER_OK;
2824 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2828 windows_kill_inferior (struct target_ops *ops)
2830 CHECK (TerminateProcess (current_process_handle, 0));
2834 if (!windows_continue (DBG_CONTINUE, -1, 1))
2836 if (!WaitForDebugEvent (¤t_event, INFINITE))
2838 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2842 target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */
2846 windows_close (struct target_ops *self)
2848 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2849 ptid_get_pid (inferior_ptid)));
2852 /* Convert pid to printable format. */
2854 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2856 static char buf[80];
2858 if (ptid_get_tid (ptid) != 0)
2860 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2861 ptid_get_pid (ptid), ptid_get_tid (ptid));
2865 return normal_pid_to_str (ptid);
2868 static enum target_xfer_status
2869 windows_xfer_shared_libraries (struct target_ops *ops,
2870 enum target_object object, const char *annex,
2871 gdb_byte *readbuf, const gdb_byte *writebuf,
2872 ULONGEST offset, ULONGEST len,
2873 ULONGEST *xfered_len)
2875 struct obstack obstack;
2881 return TARGET_XFER_E_IO;
2883 obstack_init (&obstack);
2884 obstack_grow_str (&obstack, "<library-list>\n");
2885 for (so = solib_start.next; so; so = so->next)
2887 lm_info_windows *li = (lm_info_windows *) so->lm_info;
2889 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2890 (uintptr_t) li->load_addr,
2891 target_gdbarch (), &obstack);
2893 obstack_grow_str0 (&obstack, "</library-list>\n");
2895 buf = (const char *) obstack_finish (&obstack);
2896 len_avail = strlen (buf);
2897 if (offset >= len_avail)
2901 if (len > len_avail - offset)
2902 len = len_avail - offset;
2903 memcpy (readbuf, buf + offset, len);
2906 obstack_free (&obstack, NULL);
2907 *xfered_len = (ULONGEST) len;
2908 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
2911 static enum target_xfer_status
2912 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2913 const char *annex, gdb_byte *readbuf,
2914 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2915 ULONGEST *xfered_len)
2919 case TARGET_OBJECT_MEMORY:
2920 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2922 case TARGET_OBJECT_LIBRARIES:
2923 return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2924 writebuf, offset, len, xfered_len);
2927 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2928 readbuf, writebuf, offset, len,
2933 /* Provide thread local base, i.e. Thread Information Block address.
2934 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
2937 windows_get_tib_address (struct target_ops *self,
2938 ptid_t ptid, CORE_ADDR *addr)
2940 windows_thread_info *th;
2942 th = thread_rec (ptid_get_tid (ptid), 0);
2947 *addr = th->thread_local_base;
2953 windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2955 return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2958 /* Implementation of the to_thread_name method. */
2961 windows_thread_name (struct target_ops *self, struct thread_info *thr)
2963 return thread_rec (ptid_get_tid (thr->ptid), 0)->name;
2966 static struct target_ops *
2967 windows_target (void)
2969 struct target_ops *t = inf_child_target ();
2971 t->to_close = windows_close;
2972 t->to_attach = windows_attach;
2973 t->to_attach_no_wait = 1;
2974 t->to_detach = windows_detach;
2975 t->to_resume = windows_resume;
2976 t->to_wait = windows_wait;
2977 t->to_fetch_registers = windows_fetch_inferior_registers;
2978 t->to_store_registers = windows_store_inferior_registers;
2979 t->to_xfer_partial = windows_xfer_partial;
2980 t->to_files_info = windows_files_info;
2981 t->to_kill = windows_kill_inferior;
2982 t->to_create_inferior = windows_create_inferior;
2983 t->to_mourn_inferior = windows_mourn_inferior;
2984 t->to_thread_alive = windows_thread_alive;
2985 t->to_pid_to_str = windows_pid_to_str;
2986 t->to_interrupt = windows_interrupt;
2987 t->to_pid_to_exec_file = windows_pid_to_exec_file;
2988 t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
2989 t->to_get_tib_address = windows_get_tib_address;
2990 t->to_thread_name = windows_thread_name;
2996 _initialize_windows_nat (void)
2998 struct target_ops *t;
3000 t = windows_target ();
3002 x86_use_watchpoints (t);
3004 x86_dr_low.set_control = cygwin_set_dr7;
3005 x86_dr_low.set_addr = cygwin_set_dr;
3006 x86_dr_low.get_addr = cygwin_get_dr;
3007 x86_dr_low.get_status = cygwin_get_dr6;
3008 x86_dr_low.get_control = cygwin_get_dr7;
3010 /* x86_dr_low.debug_register_length field is set by
3011 calling x86_set_debug_register_length function
3012 in processor windows specific native file. */
3017 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
3020 add_com ("signal-event", class_run, signal_event_command, _("\
3021 Signal a crashed process with event ID, to allow its debugging.\n\
3022 This command is needed in support of setting up GDB as JIT debugger on \
3023 MS-Windows. The command should be invoked from the GDB command line using \
3024 the '-ex' command-line option. The ID of the event that blocks the \
3025 crashed process will be supplied by the Windows JIT debugging mechanism."));
3028 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
3029 Set use of shell to start subprocess."), _("\
3030 Show use of shell to start subprocess."), NULL,
3032 NULL, /* FIXME: i18n: */
3033 &setlist, &showlist);
3035 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
3036 &cygwin_exceptions, _("\
3037 Break when an exception is detected in the Cygwin DLL itself."), _("\
3038 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
3040 NULL, /* FIXME: i18n: */
3041 &setlist, &showlist);
3044 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
3045 Set creation of new console when creating child process."), _("\
3046 Show creation of new console when creating child process."), NULL,
3048 NULL, /* FIXME: i18n: */
3049 &setlist, &showlist);
3051 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
3052 Set creation of new group when creating child process."), _("\
3053 Show creation of new group when creating child process."), NULL,
3055 NULL, /* FIXME: i18n: */
3056 &setlist, &showlist);
3058 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
3059 Set whether to display execution in child process."), _("\
3060 Show whether to display execution in child process."), NULL,
3062 NULL, /* FIXME: i18n: */
3063 &setlist, &showlist);
3065 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
3066 Set whether to display kernel events in child process."), _("\
3067 Show whether to display kernel events in child process."), NULL,
3069 NULL, /* FIXME: i18n: */
3070 &setlist, &showlist);
3072 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
3073 Set whether to display memory accesses in child process."), _("\
3074 Show whether to display memory accesses in child process."), NULL,
3076 NULL, /* FIXME: i18n: */
3077 &setlist, &showlist);
3079 add_setshow_boolean_cmd ("debugexceptions", class_support,
3080 &debug_exceptions, _("\
3081 Set whether to display kernel exceptions in child process."), _("\
3082 Show whether to display kernel exceptions in child process."), NULL,
3084 NULL, /* FIXME: i18n: */
3085 &setlist, &showlist);
3087 init_w32_command_list ();
3089 add_cmd ("selector", class_info, display_selectors,
3090 _("Display selectors infos."),
3094 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3096 /* Pass the address ADDR to the inferior in the I'th debug register.
3097 Here we just store the address in dr array, the registers will be
3098 actually set up when windows_continue is called. */
3100 cygwin_set_dr (int i, CORE_ADDR addr)
3103 internal_error (__FILE__, __LINE__,
3104 _("Invalid register %d in cygwin_set_dr.\n"), i);
3106 debug_registers_changed = 1;
3107 debug_registers_used = 1;
3110 /* Pass the value VAL to the inferior in the DR7 debug control
3111 register. Here we just store the address in D_REGS, the watchpoint
3112 will be actually set up in windows_wait. */
3114 cygwin_set_dr7 (unsigned long val)
3116 dr[7] = (CORE_ADDR) val;
3117 debug_registers_changed = 1;
3118 debug_registers_used = 1;
3121 /* Get the value of debug register I from the inferior. */
3124 cygwin_get_dr (int i)
3129 /* Get the value of the DR6 debug status register from the inferior.
3130 Here we just return the value stored in dr[6]
3131 by the last call to thread_rec for current_event.dwThreadId id. */
3132 static unsigned long
3133 cygwin_get_dr6 (void)
3135 return (unsigned long) dr[6];
3138 /* Get the value of the DR7 debug status register from the inferior.
3139 Here we just return the value stored in dr[7] by the last call to
3140 thread_rec for current_event.dwThreadId id. */
3142 static unsigned long
3143 cygwin_get_dr7 (void)
3145 return (unsigned long) dr[7];
3148 /* Determine if the thread referenced by "ptid" is alive
3149 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3150 it means that the thread has died. Otherwise it is assumed to be alive. */
3152 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
3156 gdb_assert (ptid_get_tid (ptid) != 0);
3157 tid = ptid_get_tid (ptid);
3159 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
3164 _initialize_check_for_gdb_ini (void)
3167 if (inhibit_gdbinit)
3170 homedir = getenv ("HOME");
3174 char *oldini = (char *) alloca (strlen (homedir) +
3175 sizeof ("gdb.ini") + 1);
3176 strcpy (oldini, homedir);
3177 p = strchr (oldini, '\0');
3178 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
3180 strcpy (p, "gdb.ini");
3181 if (access (oldini, 0) == 0)
3183 int len = strlen (oldini);
3184 char *newini = (char *) alloca (len + 2);
3186 xsnprintf (newini, len + 2, "%.*s.gdbinit",
3187 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
3188 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
3193 /* Define dummy functions which always return error for the rare cases where
3194 these functions could not be found. */
3196 bad_DebugActiveProcessStop (DWORD w)
3201 bad_DebugBreakProcess (HANDLE w)
3206 bad_DebugSetProcessKillOnExit (BOOL w)
3211 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
3218 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
3224 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
3231 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
3237 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
3243 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
3249 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
3257 /* Load any functions which may not be available in ancient versions
3261 _initialize_loadable (void)
3265 #define GPA(m, func) \
3266 func = (func ## _ftype *) GetProcAddress (m, #func)
3268 hm = LoadLibrary ("kernel32.dll");
3271 GPA (hm, DebugActiveProcessStop);
3272 GPA (hm, DebugBreakProcess);
3273 GPA (hm, DebugSetProcessKillOnExit);
3274 GPA (hm, GetConsoleFontSize);
3275 GPA (hm, DebugActiveProcessStop);
3276 GPA (hm, GetCurrentConsoleFont);
3279 /* Set variables to dummy versions of these processes if the function
3280 wasn't found in kernel32.dll. */
3281 if (!DebugBreakProcess)
3282 DebugBreakProcess = bad_DebugBreakProcess;
3283 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
3285 DebugActiveProcessStop = bad_DebugActiveProcessStop;
3286 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
3288 if (!GetConsoleFontSize)
3289 GetConsoleFontSize = bad_GetConsoleFontSize;
3290 if (!GetCurrentConsoleFont)
3291 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
3293 /* Load optional functions used for retrieving filename information
3294 associated with the currently debugged process or its dlls. */
3295 hm = LoadLibrary ("psapi.dll");
3298 GPA (hm, EnumProcessModules);
3299 GPA (hm, GetModuleInformation);
3300 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *)
3301 GetProcAddress (hm, GetModuleFileNameEx_name);
3304 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
3306 /* Set variables to dummy versions of these processes if the function
3307 wasn't found in psapi.dll. */
3308 EnumProcessModules = bad_EnumProcessModules;
3309 GetModuleInformation = bad_GetModuleInformation;
3310 GetModuleFileNameEx = bad_GetModuleFileNameEx;
3311 /* This will probably fail on Windows 9x/Me. Let the user know
3312 that we're missing some functionality. */
3314 cannot automatically find executable file or library to read symbols.\n\
3315 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3318 hm = LoadLibrary ("advapi32.dll");
3321 GPA (hm, OpenProcessToken);
3322 GPA (hm, LookupPrivilegeValueA);
3323 GPA (hm, AdjustTokenPrivileges);
3324 /* Only need to set one of these since if OpenProcessToken fails nothing
3326 if (!OpenProcessToken || !LookupPrivilegeValueA
3327 || !AdjustTokenPrivileges)
3328 OpenProcessToken = bad_OpenProcessToken;