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>
47 #include "buildsym-legacy.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
150 static CONTEXT saved_context; /* Containes the saved context from a
154 /* If we're not using the old Cygwin header file set, define the
155 following which never should have been in the generic Win32 API
156 headers in the first place since they were our own invention... */
157 #ifndef _GNU_H_WINDOWS_H
160 FLAG_TRACE_BIT = 0x100,
164 #ifndef CONTEXT_EXTENDED_REGISTERS
165 /* This macro is only defined on ia32. It only makes sense on this target,
166 so define it as zero if not already defined. */
167 #define CONTEXT_EXTENDED_REGISTERS 0
170 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \
171 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \
172 | CONTEXT_EXTENDED_REGISTERS
174 static uintptr_t dr[8];
175 static int debug_registers_changed;
176 static int debug_registers_used;
178 static int windows_initialization_done;
179 #define DR6_CLEAR_VALUE 0xffff0ff0
181 /* The exception thrown by a program to tell the debugger the name of
182 a thread. The exception record contains an ID of a thread and a
183 name to give it. This exception has no documented name, but MSDN
184 dubs it "MS_VC_EXCEPTION" in one code example. */
185 #define MS_VC_EXCEPTION 0x406d1388
189 HANDLE_EXCEPTION_UNHANDLED = 0,
190 HANDLE_EXCEPTION_HANDLED,
191 HANDLE_EXCEPTION_IGNORED
192 } handle_exception_result;
194 /* The string sent by cygwin when it processes a signal.
195 FIXME: This should be in a cygwin include file. */
196 #ifndef _CYGWIN_SIGNAL_STRING
197 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
200 #define CHECK(x) check (x, __FILE__,__LINE__)
201 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
202 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
203 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
204 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
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 /* See windows_nat_target::resume to understand why this is commented
286 /* This vector maps the target's idea of an exception (extracted
287 from the DEBUG_EVENT structure) to GDB's idea. */
289 struct xlate_exception
295 static const struct xlate_exception xlate[] =
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}
307 struct windows_nat_target final : public x86_nat_target<inf_child_target>
309 void close () override;
311 void attach (const char *, int) override;
313 bool attach_no_wait () override
316 void detach (inferior *, int) override;
318 void resume (ptid_t, int , enum gdb_signal) override;
320 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
322 void fetch_registers (struct regcache *, int) override;
323 void store_registers (struct regcache *, int) override;
325 enum target_xfer_status xfer_partial (enum target_object object,
328 const gdb_byte *writebuf,
329 ULONGEST offset, ULONGEST len,
330 ULONGEST *xfered_len) override;
332 void files_info () override;
334 void kill () override;
336 void create_inferior (const char *, const std::string &,
337 char **, int) override;
339 void mourn_inferior () override;
341 bool thread_alive (ptid_t ptid) override;
343 const char *pid_to_str (ptid_t) override;
345 void interrupt () override;
347 char *pid_to_exec_file (int pid) override;
349 ptid_t get_ada_task_ptid (long lwp, long thread) override;
351 bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
353 const char *thread_name (struct thread_info *) override;
356 static windows_nat_target the_windows_nat_target;
358 /* Set the MAPPINGS static global to OFFSETS.
359 See the description of MAPPINGS for more details. */
362 windows_set_context_register_offsets (const int *offsets)
367 /* See windows-nat.h. */
370 windows_set_segment_register_p (segment_register_p_ftype *fun)
372 segment_register_p = fun;
376 check (BOOL ok, const char *file, int line)
379 printf_filtered ("error return %s:%d was %u\n", file, line,
380 (unsigned) GetLastError ());
383 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
384 then also retrieve the context for this thread. If GET_CONTEXT is
385 negative, then don't suspend the thread. */
386 static windows_thread_info *
387 thread_rec (DWORD id, int get_context)
389 windows_thread_info *th;
391 for (th = &thread_head; (th = th->next) != NULL;)
394 if (!th->suspended && get_context)
396 if (get_context > 0 && id != current_event.dwThreadId)
398 if (SuspendThread (th->h) == (DWORD) -1)
400 DWORD err = GetLastError ();
402 /* We get Access Denied (5) when trying to suspend
403 threads that Windows started on behalf of the
404 debuggee, usually when those threads are just
406 We can get Invalid Handle (6) if the main thread
408 if (err != ERROR_INVALID_HANDLE
409 && err != ERROR_ACCESS_DENIED)
410 warning (_("SuspendThread (tid=0x%x) failed."
412 (unsigned) id, (unsigned) err);
418 else if (get_context < 0)
420 th->reload_context = 1;
428 /* Add a thread to the thread list. */
429 static windows_thread_info *
430 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
432 windows_thread_info *th;
435 gdb_assert (ptid.tid () != 0);
439 if ((th = thread_rec (id, FALSE)))
442 th = XCNEW (windows_thread_info);
445 th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
446 th->next = thread_head.next;
447 thread_head.next = th;
449 /* Set the debug registers for the new thread if they are used. */
450 if (debug_registers_used)
452 /* Only change the value of the debug registers. */
453 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
454 CHECK (GetThreadContext (th->h, &th->context));
455 th->context.Dr0 = dr[0];
456 th->context.Dr1 = dr[1];
457 th->context.Dr2 = dr[2];
458 th->context.Dr3 = dr[3];
459 th->context.Dr6 = DR6_CLEAR_VALUE;
460 th->context.Dr7 = dr[7];
461 CHECK (SetThreadContext (th->h, &th->context));
462 th->context.ContextFlags = 0;
467 /* Clear out any old thread list and reinitialize it to a
470 windows_init_thread_list (void)
472 windows_thread_info *th = &thread_head;
474 DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
476 while (th->next != NULL)
478 windows_thread_info *here = th->next;
479 th->next = here->next;
482 thread_head.next = NULL;
485 /* Delete a thread from the list of threads. */
487 windows_delete_thread (ptid_t ptid, DWORD exit_code)
489 windows_thread_info *th;
492 gdb_assert (ptid.tid () != 0);
497 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
498 else if (print_thread_events && id != main_thread_id)
499 printf_unfiltered (_("[%s exited with code %u]\n"),
500 target_pid_to_str (ptid), (unsigned) exit_code);
501 delete_thread (find_thread_ptid (ptid));
503 for (th = &thread_head;
504 th->next != NULL && th->next->id != id;
508 if (th->next != NULL)
510 windows_thread_info *here = th->next;
511 th->next = here->next;
517 /* Fetches register number R from the given windows_thread_info,
518 and supplies its value to the given regcache.
520 This function assumes that R is non-negative. A failed assertion
521 is raised if that is not true.
523 This function assumes that TH->RELOAD_CONTEXT is not set, meaning
524 that the windows_thread_info has an up-to-date context. A failed
525 assertion is raised if that assumption is violated. */
528 windows_fetch_one_register (struct regcache *regcache,
529 windows_thread_info *th, int r)
532 gdb_assert (!th->reload_context);
534 char *context_offset = ((char *) &th->context) + mappings[r];
535 struct gdbarch *gdbarch = regcache->arch ();
536 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
538 if (r == I387_FISEG_REGNUM (tdep))
540 long l = *((long *) context_offset) & 0xffff;
541 regcache->raw_supply (r, (char *) &l);
543 else if (r == I387_FOP_REGNUM (tdep))
545 long l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
546 regcache->raw_supply (r, (char *) &l);
548 else if (segment_register_p (r))
550 /* GDB treats segment registers as 32bit registers, but they are
551 in fact only 16 bits long. Make sure we do not read extra
552 bits from our source buffer. */
553 long l = *((long *) context_offset) & 0xffff;
554 regcache->raw_supply (r, (char *) &l);
557 regcache->raw_supply (r, context_offset);
561 windows_nat_target::fetch_registers (struct regcache *regcache, int r)
563 DWORD pid = regcache->ptid ().tid ();
564 windows_thread_info *th = thread_rec (pid, TRUE);
566 /* Check if TH exists. Windows sometimes uses a non-existent
567 thread id in its events. */
571 if (th->reload_context)
574 if (have_saved_context)
576 /* Lie about where the program actually is stopped since
577 cygwin has informed us that we should consider the signal
578 to have occurred at another location which is stored in
580 memcpy (&th->context, &saved_context,
581 __COPY_CONTEXT_SIZE);
582 have_saved_context = 0;
587 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
588 CHECK (GetThreadContext (th->h, &th->context));
589 /* Copy dr values from that thread.
590 But only if there were not modified since last stop.
592 if (!debug_registers_changed)
594 dr[0] = th->context.Dr0;
595 dr[1] = th->context.Dr1;
596 dr[2] = th->context.Dr2;
597 dr[3] = th->context.Dr3;
598 dr[6] = th->context.Dr6;
599 dr[7] = th->context.Dr7;
602 th->reload_context = 0;
606 for (r = 0; r < gdbarch_num_regs (regcache->arch()); r++)
607 windows_fetch_one_register (regcache, th, r);
609 windows_fetch_one_register (regcache, th, r);
612 /* Collect the register number R from the given regcache, and store
613 its value into the corresponding area of the given thread's context.
615 This function assumes that R is non-negative. A failed assertion
616 assertion is raised if that is not true. */
619 windows_store_one_register (const struct regcache *regcache,
620 windows_thread_info *th, int r)
624 regcache->raw_collect (r, ((char *) &th->context) + mappings[r]);
627 /* Store a new register value into the context of the thread tied to
631 windows_nat_target::store_registers (struct regcache *regcache, int r)
633 DWORD pid = regcache->ptid ().tid ();
634 windows_thread_info *th = thread_rec (pid, TRUE);
636 /* Check if TH exists. Windows sometimes uses a non-existent
637 thread id in its events. */
642 for (r = 0; r < gdbarch_num_regs (regcache->arch ()); r++)
643 windows_store_one_register (regcache, th, r);
645 windows_store_one_register (regcache, th, r);
648 /* Encapsulate the information required in a call to
649 symbol_file_add_args. */
650 struct safe_symbol_file_add_args
654 section_addr_info *addrs;
657 struct ui_file *err, *out;
661 /* Maintain a linked list of "so" information. */
662 struct lm_info_windows : public lm_info_base
664 LPVOID load_addr = 0;
667 static struct so_list solib_start, *solib_end;
669 static struct so_list *
670 windows_make_so (const char *name, LPVOID load_addr)
677 WIN32_FIND_DATA w32_fd;
678 HANDLE h = FindFirstFile(name, &w32_fd);
680 if (h == INVALID_HANDLE_VALUE)
686 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
688 p = strrchr (buf, '\\');
691 SetCurrentDirectory (buf);
692 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
693 SetCurrentDirectory (cwd);
696 if (strcasecmp (buf, "ntdll.dll") == 0)
698 GetSystemDirectory (buf, sizeof (buf));
699 strcat (buf, "\\ntdll.dll");
702 cygwin_buf_t buf[__PMAX];
705 if (access (name, F_OK) != 0)
707 if (strcasecmp (name, "ntdll.dll") == 0)
710 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
711 wcscat (buf, L"\\ntdll.dll");
715 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
716 strcat (buf, "\\ntdll.dll");
721 so = XCNEW (struct so_list);
722 lm_info_windows *li = new lm_info_windows;
724 li->load_addr = load_addr;
725 strcpy (so->so_original_name, name);
727 strcpy (so->so_name, buf);
730 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
731 SO_NAME_MAX_PATH_SIZE);
734 char *rname = realpath (name, NULL);
735 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
737 strcpy (so->so_name, rname);
741 error (_("dll path too long"));
743 /* Record cygwin1.dll .text start/end. */
744 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
745 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
747 asection *text = NULL;
750 gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386", -1));
755 if (bfd_check_format (abfd.get (), bfd_object))
756 text = bfd_get_section_by_name (abfd.get (), ".text");
761 /* The symbols in a dll are offset by 0x1000, which is the
762 offset from 0 of the first byte in an image - because of the
763 file header and the section alignment. */
764 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
766 cygwin_load_end = cygwin_load_start + bfd_section_size (abfd.get (),
775 get_image_name (HANDLE h, void *address, int unicode)
778 static char buf[__PMAX];
780 static char buf[(2 * __PMAX) + 1];
782 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
788 /* Attempt to read the name of the dll that was detected.
789 This is documented to work only when actively debugging
790 a program. It will not work for attached processes. */
794 /* See if we could read the address of a string, and that the
795 address isn't null. */
796 if (!ReadProcessMemory (h, address, &address_ptr,
797 sizeof (address_ptr), &done)
798 || done != sizeof (address_ptr) || !address_ptr)
801 /* Find the length of the string. */
802 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
803 && (b[0] != 0 || b[size - 1] != 0) && done == size)
807 ReadProcessMemory (h, address_ptr, buf, len, &done);
810 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
811 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
814 wcstombs (buf, unicode_address, __PMAX);
816 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
824 /* Handle a DLL load event, and return 1.
826 This function assumes that this event did not occur during inferior
827 initialization, where their event info may be incomplete (see
828 do_initial_windows_stuff and windows_add_all_dlls for more info
829 on how we handle DLL loading during that phase). */
834 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
837 /* Try getting the DLL name via the lpImageName field of the event.
838 Note that Microsoft documents this fields as strictly optional,
839 in the sense that it might be NULL. And the first DLL event in
840 particular is explicitly documented as "likely not pass[ed]"
841 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */
842 dll_name = get_image_name (current_process_handle,
843 event->lpImageName, event->fUnicode);
847 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
848 solib_end = solib_end->next;
850 lm_info_windows *li = (lm_info_windows *) solib_end->lm_info;
852 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
853 host_address_to_string (li->load_addr)));
857 windows_free_so (struct so_list *so)
859 lm_info_windows *li = (lm_info_windows *) so->lm_info;
865 /* Handle a DLL unload event.
866 Return 1 if successful, or zero otherwise.
868 This function assumes that this event did not occur during inferior
869 initialization, where their event info may be incomplete (see
870 do_initial_windows_stuff and windows_add_all_dlls for more info
871 on how we handle DLL loading during that phase). */
876 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
879 for (so = &solib_start; so->next != NULL; so = so->next)
881 lm_info_windows *li_next = (lm_info_windows *) so->next->lm_info;
883 if (li_next->load_addr == lpBaseOfDll)
885 struct so_list *sodel = so->next;
887 so->next = sodel->next;
890 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
892 windows_free_so (sodel);
897 /* We did not find any DLL that was previously loaded at this address,
898 so register a complaint. We do not report an error, because we have
899 observed that this may be happening under some circumstances. For
900 instance, running 32bit applications on x64 Windows causes us to receive
901 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
902 events are apparently caused by the WOW layer, the interface between
903 32bit and 64bit worlds). */
904 complaint (_("dll starting at %s not found."),
905 host_address_to_string (lpBaseOfDll));
908 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
912 catch_errors (void (*func) ())
918 CATCH (ex, RETURN_MASK_ALL)
920 exception_print (gdb_stderr, ex);
925 /* Clear list of loaded DLLs. */
927 windows_clear_solib (void)
929 solib_start.next = NULL;
930 solib_end = &solib_start;
934 signal_event_command (const char *args, int from_tty)
936 uintptr_t event_id = 0;
937 char *endargs = NULL;
940 error (_("signal-event requires an argument (integer event id)"));
942 event_id = strtoumax (args, &endargs, 10);
944 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) ||
945 ((HANDLE) event_id == INVALID_HANDLE_VALUE))
946 error (_("Failed to convert `%s' to event id"), args);
948 SetEvent ((HANDLE) event_id);
949 CloseHandle ((HANDLE) event_id);
952 /* Handle DEBUG_STRING output from child process.
953 Cygwin prepends its messages with a "cygwin:". Interpret this as
954 a Cygwin signal. Otherwise just print the string as a warning. */
956 handle_output_debug_string (struct target_waitstatus *ourstatus)
958 gdb::unique_xmalloc_ptr<char> s;
961 if (!target_read_string
962 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
964 || !s || !*(s.get ()))
966 else if (!startswith (s.get (), _CYGWIN_SIGNAL_STRING))
969 if (!startswith (s.get (), "cYg"))
972 char *p = strchr (s.get (), '\0');
974 if (p > s.get () && *--p == '\n')
976 warning (("%s"), s.get ());
982 /* Got a cygwin signal marker. A cygwin signal is followed by
983 the signal number itself and then optionally followed by the
984 thread id and address to saved context within the DLL. If
985 these are supplied, then the given thread is assumed to have
986 issued the signal and the context from the thread is assumed
987 to be stored at the given address in the inferior. Tell gdb
988 to treat this like a real signal. */
990 int sig = strtol (s.get () + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
991 gdb_signal gotasig = gdb_signal_from_host (sig);
993 ourstatus->value.sig = gotasig;
999 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1000 retval = strtoul (p, &p, 0);
1002 retval = main_thread_id;
1003 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
1004 && ReadProcessMemory (current_process_handle, x,
1006 __COPY_CONTEXT_SIZE, &n)
1007 && n == __COPY_CONTEXT_SIZE)
1008 have_saved_context = 1;
1017 display_selector (HANDLE thread, DWORD sel)
1020 if (GetThreadSelectorEntry (thread, sel, &info))
1023 printf_filtered ("0x%03x: ", (unsigned) sel);
1024 if (!info.HighWord.Bits.Pres)
1026 puts_filtered ("Segment not present\n");
1029 base = (info.HighWord.Bits.BaseHi << 24) +
1030 (info.HighWord.Bits.BaseMid << 16)
1032 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
1033 if (info.HighWord.Bits.Granularity)
1034 limit = (limit << 12) | 0xfff;
1035 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
1036 if (info.HighWord.Bits.Default_Big)
1037 puts_filtered(" 32-bit ");
1039 puts_filtered(" 16-bit ");
1040 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
1043 puts_filtered ("Data (Read-Only, Exp-up");
1046 puts_filtered ("Data (Read/Write, Exp-up");
1049 puts_filtered ("Unused segment (");
1052 puts_filtered ("Data (Read/Write, Exp-down");
1055 puts_filtered ("Code (Exec-Only, N.Conf");
1058 puts_filtered ("Code (Exec/Read, N.Conf");
1061 puts_filtered ("Code (Exec-Only, Conf");
1064 puts_filtered ("Code (Exec/Read, Conf");
1067 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
1069 if ((info.HighWord.Bits.Type & 0x1) == 0)
1070 puts_filtered(", N.Acc");
1071 puts_filtered (")\n");
1072 if ((info.HighWord.Bits.Type & 0x10) == 0)
1073 puts_filtered("System selector ");
1074 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1075 if (info.HighWord.Bits.Granularity)
1076 puts_filtered ("Page granular.\n");
1078 puts_filtered ("Byte granular.\n");
1083 DWORD err = GetLastError ();
1084 if (err == ERROR_NOT_SUPPORTED)
1085 printf_filtered ("Function not supported\n");
1087 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
1093 display_selectors (const char * args, int from_tty)
1095 if (!current_thread)
1097 puts_filtered ("Impossible to display selectors now.\n");
1103 puts_filtered ("Selector $cs\n");
1104 display_selector (current_thread->h,
1105 current_thread->context.SegCs);
1106 puts_filtered ("Selector $ds\n");
1107 display_selector (current_thread->h,
1108 current_thread->context.SegDs);
1109 puts_filtered ("Selector $es\n");
1110 display_selector (current_thread->h,
1111 current_thread->context.SegEs);
1112 puts_filtered ("Selector $ss\n");
1113 display_selector (current_thread->h,
1114 current_thread->context.SegSs);
1115 puts_filtered ("Selector $fs\n");
1116 display_selector (current_thread->h,
1117 current_thread->context.SegFs);
1118 puts_filtered ("Selector $gs\n");
1119 display_selector (current_thread->h,
1120 current_thread->context.SegGs);
1125 sel = parse_and_eval_long (args);
1126 printf_filtered ("Selector \"%s\"\n",args);
1127 display_selector (current_thread->h, sel);
1131 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1132 printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
1133 host_address_to_string (\
1134 current_event.u.Exception.ExceptionRecord.ExceptionAddress))
1136 static handle_exception_result
1137 handle_exception (struct target_waitstatus *ourstatus)
1139 EXCEPTION_RECORD *rec = ¤t_event.u.Exception.ExceptionRecord;
1140 DWORD code = rec->ExceptionCode;
1141 handle_exception_result result = HANDLE_EXCEPTION_HANDLED;
1143 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1145 /* Record the context of the current thread. */
1146 thread_rec (current_event.dwThreadId, -1);
1150 case EXCEPTION_ACCESS_VIOLATION:
1151 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1152 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1155 /* See if the access violation happened within the cygwin DLL
1156 itself. Cygwin uses a kind of exception handling to deal
1157 with passed-in invalid addresses. gdb should not treat
1158 these as real SEGVs since they will be silently handled by
1159 cygwin. A real SEGV will (theoretically) be caught by
1160 cygwin later in the process and will be sent as a
1161 cygwin-specific-signal. So, ignore SEGVs if they show up
1162 within the text segment of the DLL itself. */
1164 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress;
1166 if ((!cygwin_exceptions && (addr >= cygwin_load_start
1167 && addr < cygwin_load_end))
1168 || (find_pc_partial_function (addr, &fn, NULL, NULL)
1169 && startswith (fn, "KERNEL32!IsBad")))
1170 return HANDLE_EXCEPTION_UNHANDLED;
1174 case STATUS_STACK_OVERFLOW:
1175 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1176 ourstatus->value.sig = GDB_SIGNAL_SEGV;
1178 case STATUS_FLOAT_DENORMAL_OPERAND:
1179 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1180 ourstatus->value.sig = GDB_SIGNAL_FPE;
1182 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1183 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1184 ourstatus->value.sig = GDB_SIGNAL_FPE;
1186 case STATUS_FLOAT_INEXACT_RESULT:
1187 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1188 ourstatus->value.sig = GDB_SIGNAL_FPE;
1190 case STATUS_FLOAT_INVALID_OPERATION:
1191 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1192 ourstatus->value.sig = GDB_SIGNAL_FPE;
1194 case STATUS_FLOAT_OVERFLOW:
1195 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1196 ourstatus->value.sig = GDB_SIGNAL_FPE;
1198 case STATUS_FLOAT_STACK_CHECK:
1199 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1200 ourstatus->value.sig = GDB_SIGNAL_FPE;
1202 case STATUS_FLOAT_UNDERFLOW:
1203 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1204 ourstatus->value.sig = GDB_SIGNAL_FPE;
1206 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1207 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1208 ourstatus->value.sig = GDB_SIGNAL_FPE;
1210 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1211 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1212 ourstatus->value.sig = GDB_SIGNAL_FPE;
1214 case STATUS_INTEGER_OVERFLOW:
1215 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1216 ourstatus->value.sig = GDB_SIGNAL_FPE;
1218 case EXCEPTION_BREAKPOINT:
1219 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1220 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1223 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1224 ourstatus->value.sig = GDB_SIGNAL_INT;
1226 case DBG_CONTROL_BREAK:
1227 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1228 ourstatus->value.sig = GDB_SIGNAL_INT;
1230 case EXCEPTION_SINGLE_STEP:
1231 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1232 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1234 case EXCEPTION_ILLEGAL_INSTRUCTION:
1235 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1236 ourstatus->value.sig = GDB_SIGNAL_ILL;
1238 case EXCEPTION_PRIV_INSTRUCTION:
1239 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1240 ourstatus->value.sig = GDB_SIGNAL_ILL;
1242 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1243 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1244 ourstatus->value.sig = GDB_SIGNAL_ILL;
1246 case MS_VC_EXCEPTION:
1247 if (rec->NumberParameters >= 3
1248 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
1250 DWORD named_thread_id;
1251 windows_thread_info *named_thread;
1252 CORE_ADDR thread_name_target;
1254 DEBUG_EXCEPTION_SIMPLE ("MS_VC_EXCEPTION");
1256 thread_name_target = rec->ExceptionInformation[1];
1257 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]);
1259 if (named_thread_id == (DWORD) -1)
1260 named_thread_id = current_event.dwThreadId;
1262 named_thread = thread_rec (named_thread_id, 0);
1263 if (named_thread != NULL)
1265 int thread_name_len;
1266 gdb::unique_xmalloc_ptr<char> thread_name;
1268 thread_name_len = target_read_string (thread_name_target,
1269 &thread_name, 1025, NULL);
1270 if (thread_name_len > 0)
1272 thread_name.get ()[thread_name_len - 1] = '\0';
1273 xfree (named_thread->name);
1274 named_thread->name = thread_name.release ();
1277 ourstatus->value.sig = GDB_SIGNAL_TRAP;
1278 result = HANDLE_EXCEPTION_IGNORED;
1281 /* treat improperly formed exception as unknown */
1284 /* Treat unhandled first chance exceptions specially. */
1285 if (current_event.u.Exception.dwFirstChance)
1286 return HANDLE_EXCEPTION_UNHANDLED;
1287 printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
1288 (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
1289 host_address_to_string (
1290 current_event.u.Exception.ExceptionRecord.ExceptionAddress));
1291 ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
1295 last_sig = ourstatus->value.sig;
1299 /* Resume thread specified by ID, or all artificially suspended
1300 threads, if we are continuing execution. KILLED non-zero means we
1301 have killed the inferior, so we should ignore weird errors due to
1302 threads shutting down. */
1304 windows_continue (DWORD continue_status, int id, int killed)
1306 windows_thread_info *th;
1309 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
1310 (unsigned) current_event.dwProcessId,
1311 (unsigned) current_event.dwThreadId,
1312 continue_status == DBG_CONTINUE ?
1313 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1315 for (th = &thread_head; (th = th->next) != NULL;)
1316 if ((id == -1 || id == (int) th->id)
1319 if (debug_registers_changed)
1321 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1322 th->context.Dr0 = dr[0];
1323 th->context.Dr1 = dr[1];
1324 th->context.Dr2 = dr[2];
1325 th->context.Dr3 = dr[3];
1326 th->context.Dr6 = DR6_CLEAR_VALUE;
1327 th->context.Dr7 = dr[7];
1329 if (th->context.ContextFlags)
1333 if (GetExitCodeThread (th->h, &ec)
1334 && ec == STILL_ACTIVE)
1336 BOOL status = SetThreadContext (th->h, &th->context);
1341 th->context.ContextFlags = 0;
1343 if (th->suspended > 0)
1344 (void) ResumeThread (th->h);
1348 res = ContinueDebugEvent (current_event.dwProcessId,
1349 current_event.dwThreadId,
1353 error (_("Failed to resume program execution"
1354 " (ContinueDebugEvent failed, error %u)"),
1355 (unsigned int) GetLastError ());
1357 debug_registers_changed = 0;
1361 /* Called in pathological case where Windows fails to send a
1362 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1364 fake_create_process (void)
1366 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1367 current_event.dwProcessId);
1368 if (current_process_handle != NULL)
1369 open_process_used = 1;
1372 error (_("OpenProcess call failed, GetLastError = %u"),
1373 (unsigned) GetLastError ());
1374 /* We can not debug anything in that case. */
1376 main_thread_id = current_event.dwThreadId;
1377 current_thread = windows_add_thread (
1378 ptid_t (current_event.dwProcessId, 0,
1379 current_event.dwThreadId),
1380 current_event.u.CreateThread.hThread,
1381 current_event.u.CreateThread.lpThreadLocalBase);
1382 return main_thread_id;
1386 windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
1388 windows_thread_info *th;
1389 DWORD continue_status = DBG_CONTINUE;
1391 /* A specific PTID means `step only this thread id'. */
1392 int resume_all = ptid == minus_one_ptid;
1394 /* If we're continuing all threads, it's the current inferior that
1395 should be handled specially. */
1397 ptid = inferior_ptid;
1399 if (sig != GDB_SIGNAL_0)
1401 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1403 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1405 else if (sig == last_sig)
1406 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1409 /* This code does not seem to work, because
1410 the kernel does probably not consider changes in the ExceptionRecord
1411 structure when passing the exception to the inferior.
1412 Note that this seems possible in the exception handler itself. */
1414 for (const xlate_exception &x : xlate)
1417 current_event.u.Exception.ExceptionRecord.ExceptionCode
1419 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1422 if (continue_status == DBG_CONTINUE)
1424 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1428 DEBUG_EXCEPT(("Can only continue with received signal %d.\n",
1432 last_sig = GDB_SIGNAL_0;
1434 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1435 ptid.pid (), ptid.tid (), step, sig));
1437 /* Get context for currently selected thread. */
1438 th = thread_rec (inferior_ptid.tid (), FALSE);
1443 /* Single step by setting t bit. */
1444 struct regcache *regcache = get_current_regcache ();
1445 struct gdbarch *gdbarch = regcache->arch ();
1446 fetch_registers (regcache, gdbarch_ps_regnum (gdbarch));
1447 th->context.EFlags |= FLAG_TRACE_BIT;
1450 if (th->context.ContextFlags)
1452 if (debug_registers_changed)
1454 th->context.Dr0 = dr[0];
1455 th->context.Dr1 = dr[1];
1456 th->context.Dr2 = dr[2];
1457 th->context.Dr3 = dr[3];
1458 th->context.Dr6 = DR6_CLEAR_VALUE;
1459 th->context.Dr7 = dr[7];
1461 CHECK (SetThreadContext (th->h, &th->context));
1462 th->context.ContextFlags = 0;
1466 /* Allow continuing with the same signal that interrupted us.
1467 Otherwise complain. */
1470 windows_continue (continue_status, -1, 0);
1472 windows_continue (continue_status, ptid.tid (), 0);
1475 /* Ctrl-C handler used when the inferior is not run in the same console. The
1476 handler is in charge of interrupting the inferior using DebugBreakProcess.
1477 Note that this function is not available prior to Windows XP. In this case
1478 we emit a warning. */
1480 ctrl_c_handler (DWORD event_type)
1482 const int attach_flag = current_inferior ()->attach_flag;
1484 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
1485 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
1488 /* If the inferior and the debugger share the same console, do nothing as
1489 the inferior has also received the Ctrl-C event. */
1490 if (!new_console && !attach_flag)
1493 if (!DebugBreakProcess (current_process_handle))
1494 warning (_("Could not interrupt program. "
1495 "Press Ctrl-c in the program console."));
1497 /* Return true to tell that Ctrl-C has been handled. */
1501 /* Get the next event from the child. Returns a non-zero thread id if the event
1502 requires handling by WFI (or whatever). */
1504 get_windows_debug_event (struct target_ops *ops,
1505 int pid, struct target_waitstatus *ourstatus)
1508 DWORD continue_status, event_code;
1509 windows_thread_info *th;
1510 static windows_thread_info dummy_thread_info;
1511 DWORD thread_id = 0;
1513 last_sig = GDB_SIGNAL_0;
1515 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1519 continue_status = DBG_CONTINUE;
1521 event_code = current_event.dwDebugEventCode;
1522 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1524 have_saved_context = 0;
1528 case CREATE_THREAD_DEBUG_EVENT:
1529 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1530 (unsigned) current_event.dwProcessId,
1531 (unsigned) current_event.dwThreadId,
1532 "CREATE_THREAD_DEBUG_EVENT"));
1533 if (saw_create != 1)
1535 struct inferior *inf;
1536 inf = find_inferior_pid (current_event.dwProcessId);
1537 if (!saw_create && inf->attach_flag)
1539 /* Kludge around a Windows bug where first event is a create
1540 thread event. Caused when attached process does not have
1542 thread_id = fake_create_process ();
1548 /* Record the existence of this thread. */
1549 thread_id = current_event.dwThreadId;
1550 th = windows_add_thread (ptid_t (current_event.dwProcessId, 0,
1551 current_event.dwThreadId),
1552 current_event.u.CreateThread.hThread,
1553 current_event.u.CreateThread.lpThreadLocalBase);
1557 case EXIT_THREAD_DEBUG_EVENT:
1558 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1559 (unsigned) current_event.dwProcessId,
1560 (unsigned) current_event.dwThreadId,
1561 "EXIT_THREAD_DEBUG_EVENT"));
1563 if (current_event.dwThreadId != main_thread_id)
1565 windows_delete_thread (ptid_t (current_event.dwProcessId, 0,
1566 current_event.dwThreadId),
1567 current_event.u.ExitThread.dwExitCode);
1568 th = &dummy_thread_info;
1572 case CREATE_PROCESS_DEBUG_EVENT:
1573 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1574 (unsigned) current_event.dwProcessId,
1575 (unsigned) current_event.dwThreadId,
1576 "CREATE_PROCESS_DEBUG_EVENT"));
1577 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1578 if (++saw_create != 1)
1581 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1583 windows_delete_thread (ptid_t (current_event.dwProcessId, 0,
1586 main_thread_id = current_event.dwThreadId;
1587 /* Add the main thread. */
1588 th = windows_add_thread (ptid_t (current_event.dwProcessId, 0,
1589 current_event.dwThreadId),
1590 current_event.u.CreateProcessInfo.hThread,
1591 current_event.u.CreateProcessInfo.lpThreadLocalBase);
1592 thread_id = current_event.dwThreadId;
1595 case EXIT_PROCESS_DEBUG_EVENT:
1596 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1597 (unsigned) current_event.dwProcessId,
1598 (unsigned) current_event.dwThreadId,
1599 "EXIT_PROCESS_DEBUG_EVENT"));
1600 if (!windows_initialization_done)
1602 target_terminal::ours ();
1603 target_mourn_inferior (inferior_ptid);
1604 error (_("During startup program exited with code 0x%x."),
1605 (unsigned int) current_event.u.ExitProcess.dwExitCode);
1607 else if (saw_create == 1)
1609 ourstatus->kind = TARGET_WAITKIND_EXITED;
1610 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1611 thread_id = main_thread_id;
1615 case LOAD_DLL_DEBUG_EVENT:
1616 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1617 (unsigned) current_event.dwProcessId,
1618 (unsigned) current_event.dwThreadId,
1619 "LOAD_DLL_DEBUG_EVENT"));
1620 CloseHandle (current_event.u.LoadDll.hFile);
1621 if (saw_create != 1 || ! windows_initialization_done)
1623 catch_errors (handle_load_dll);
1624 ourstatus->kind = TARGET_WAITKIND_LOADED;
1625 ourstatus->value.integer = 0;
1626 thread_id = main_thread_id;
1629 case UNLOAD_DLL_DEBUG_EVENT:
1630 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1631 (unsigned) current_event.dwProcessId,
1632 (unsigned) current_event.dwThreadId,
1633 "UNLOAD_DLL_DEBUG_EVENT"));
1634 if (saw_create != 1 || ! windows_initialization_done)
1636 catch_errors (handle_unload_dll);
1637 ourstatus->kind = TARGET_WAITKIND_LOADED;
1638 ourstatus->value.integer = 0;
1639 thread_id = main_thread_id;
1642 case EXCEPTION_DEBUG_EVENT:
1643 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1644 (unsigned) current_event.dwProcessId,
1645 (unsigned) current_event.dwThreadId,
1646 "EXCEPTION_DEBUG_EVENT"));
1647 if (saw_create != 1)
1649 switch (handle_exception (ourstatus))
1651 case HANDLE_EXCEPTION_UNHANDLED:
1653 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1655 case HANDLE_EXCEPTION_HANDLED:
1656 thread_id = current_event.dwThreadId;
1658 case HANDLE_EXCEPTION_IGNORED:
1659 continue_status = DBG_CONTINUE;
1664 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
1665 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
1666 (unsigned) current_event.dwProcessId,
1667 (unsigned) current_event.dwThreadId,
1668 "OUTPUT_DEBUG_STRING_EVENT"));
1669 if (saw_create != 1)
1671 thread_id = handle_output_debug_string (ourstatus);
1675 if (saw_create != 1)
1677 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
1678 (unsigned) current_event.dwProcessId,
1679 (unsigned) current_event.dwThreadId);
1680 printf_unfiltered (" unknown event code %u\n",
1681 (unsigned) current_event.dwDebugEventCode);
1685 if (!thread_id || saw_create != 1)
1687 CHECK (windows_continue (continue_status, -1, 0));
1691 inferior_ptid = ptid_t (current_event.dwProcessId, 0, thread_id);
1692 current_thread = th;
1693 if (!current_thread)
1694 current_thread = thread_rec (thread_id, TRUE);
1701 /* Wait for interesting events to occur in the target process. */
1703 windows_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
1708 /* We loop when we get a non-standard exception rather than return
1709 with a SPURIOUS because resume can try and step or modify things,
1710 which needs a current_thread->h. But some of these exceptions mark
1711 the birth or death of threads, which mean that the current thread
1712 isn't necessarily what you think it is. */
1718 /* If the user presses Ctrl-c while the debugger is waiting
1719 for an event, he expects the debugger to interrupt his program
1720 and to get the prompt back. There are two possible situations:
1722 - The debugger and the program do not share the console, in
1723 which case the Ctrl-c event only reached the debugger.
1724 In that case, the ctrl_c handler will take care of interrupting
1725 the inferior. Note that this case is working starting with
1726 Windows XP. For Windows 2000, Ctrl-C should be pressed in the
1729 - The debugger and the program share the same console, in which
1730 case both debugger and inferior will receive the Ctrl-c event.
1731 In that case the ctrl_c handler will ignore the event, as the
1732 Ctrl-c event generated inside the inferior will trigger the
1733 expected debug event.
1735 FIXME: brobecker/2008-05-20: If the inferior receives the
1736 signal first and the delay until GDB receives that signal
1737 is sufficiently long, GDB can sometimes receive the SIGINT
1738 after we have unblocked the CTRL+C handler. This would
1739 lead to the debugger stopping prematurely while handling
1740 the new-thread event that comes with the handling of the SIGINT
1741 inside the inferior, and then stop again immediately when
1742 the user tries to resume the execution in the inferior.
1743 This is a classic race that we should try to fix one day. */
1744 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
1745 retval = get_windows_debug_event (this, pid, ourstatus);
1746 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
1749 return ptid_t (current_event.dwProcessId, 0, retval);
1754 if (deprecated_ui_loop_hook != NULL)
1755 detach = deprecated_ui_loop_hook (0);
1763 /* Iterate over all DLLs currently mapped by our inferior, and
1764 add them to our list of solibs. */
1767 windows_add_all_dlls (void)
1769 HMODULE dummy_hmodule;
1774 if (EnumProcessModules (current_process_handle, &dummy_hmodule,
1775 sizeof (HMODULE), &cb_needed) == 0)
1781 hmodules = (HMODULE *) alloca (cb_needed);
1782 if (EnumProcessModules (current_process_handle, hmodules,
1783 cb_needed, &cb_needed) == 0)
1786 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
1790 wchar_t dll_name[__PMAX];
1793 char dll_name[__PMAX];
1796 if (GetModuleInformation (current_process_handle, hmodules[i],
1797 &mi, sizeof (mi)) == 0)
1799 if (GetModuleFileNameEx (current_process_handle, hmodules[i],
1800 dll_name, sizeof (dll_name)) == 0)
1803 wcstombs (name, dll_name, __PMAX);
1808 solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
1809 solib_end = solib_end->next;
1814 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1817 struct inferior *inf;
1819 last_sig = GDB_SIGNAL_0;
1821 exception_count = 0;
1822 open_process_used = 0;
1823 debug_registers_changed = 0;
1824 debug_registers_used = 0;
1825 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1828 cygwin_load_start = cygwin_load_end = 0;
1830 current_event.dwProcessId = pid;
1831 memset (¤t_event, 0, sizeof (current_event));
1832 if (!target_is_pushed (ops))
1834 disable_breakpoints_in_shlibs ();
1835 windows_clear_solib ();
1836 clear_proceed_status (0);
1837 init_wait_for_inferior ();
1839 inf = current_inferior ();
1840 inferior_appeared (inf, pid);
1841 inf->attach_flag = attaching;
1843 /* Make the new process the current inferior, so terminal handling
1844 can rely on it. When attaching, we don't know about any thread
1845 id here, but that's OK --- nothing should be referencing the
1846 current thread until we report an event out of windows_wait. */
1847 inferior_ptid = ptid_t (pid);
1849 target_terminal::init ();
1850 target_terminal::inferior ();
1852 windows_initialization_done = 0;
1856 struct target_waitstatus status;
1858 ops->wait (minus_one_ptid, &status, 0);
1860 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread
1862 if (status.kind != TARGET_WAITKIND_LOADED
1863 && status.kind != TARGET_WAITKIND_SPURIOUS)
1866 ops->resume (minus_one_ptid, 0, GDB_SIGNAL_0);
1869 /* Now that the inferior has been started and all DLLs have been mapped,
1870 we can iterate over all DLLs and load them in.
1872 We avoid doing it any earlier because, on certain versions of Windows,
1873 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular,
1874 we have seen on Windows 8.1 that the ntdll.dll load event does not
1875 include the DLL name, preventing us from creating an associated SO.
1876 A possible explanation is that ntdll.dll might be mapped before
1877 the SO info gets created by the Windows system -- ntdll.dll is
1878 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
1879 do not seem to suffer from that problem.
1881 Rather than try to work around this sort of issue, it is much
1882 simpler to just ignore DLL load/unload events during the startup
1883 phase, and then process them all in one batch now. */
1884 windows_add_all_dlls ();
1886 windows_initialization_done = 1;
1890 /* Try to set or remove a user privilege to the current process. Return -1
1891 if that fails, the previous setting of that privilege otherwise.
1893 This code is copied from the Cygwin source code and rearranged to allow
1894 dynamically loading of the needed symbols from advapi32 which is only
1895 available on NT/2K/XP. */
1897 set_process_privilege (const char *privilege, BOOL enable)
1899 HANDLE token_hdl = NULL;
1901 TOKEN_PRIVILEGES new_priv, orig_priv;
1905 if (!OpenProcessToken (GetCurrentProcess (),
1906 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1910 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
1913 new_priv.PrivilegeCount = 1;
1914 new_priv.Privileges[0].Luid = restore_priv;
1915 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1917 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1918 sizeof orig_priv, &orig_priv, &size))
1921 /* Disabled, otherwise every `attach' in an unprivileged user session
1922 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1923 windows_attach(). */
1924 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1925 be enabled. GetLastError () returns an correct error code, though. */
1926 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1930 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1934 CloseHandle (token_hdl);
1939 /* Attach to process PID, then initialize for debugging it. */
1942 windows_nat_target::attach (const char *args, int from_tty)
1947 pid = parse_pid_to_attach (args);
1949 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1951 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1952 printf_unfiltered ("This can cause attach to "
1953 "fail on Windows NT/2K/XP\n");
1956 windows_init_thread_list ();
1957 ok = DebugActiveProcess (pid);
1963 /* Try fall back to Cygwin pid. */
1964 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1967 ok = DebugActiveProcess (pid);
1972 error (_("Can't attach to process."));
1974 DebugSetProcessKillOnExit (FALSE);
1978 char *exec_file = (char *) get_exec_file (0);
1981 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1982 target_pid_to_str (ptid_t (pid)));
1984 printf_unfiltered ("Attaching to %s\n",
1985 target_pid_to_str (ptid_t (pid)));
1987 gdb_flush (gdb_stdout);
1990 do_initial_windows_stuff (this, pid, 1);
1991 target_terminal::ours ();
1995 windows_nat_target::detach (inferior *inf, int from_tty)
1999 ptid_t ptid = minus_one_ptid;
2000 resume (ptid, 0, GDB_SIGNAL_0);
2002 if (!DebugActiveProcessStop (current_event.dwProcessId))
2004 error (_("Can't detach process %u (error %u)"),
2005 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
2008 DebugSetProcessKillOnExit (FALSE);
2010 if (detached && from_tty)
2012 const char *exec_file = get_exec_file (0);
2015 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
2016 (unsigned) current_event.dwProcessId);
2017 gdb_flush (gdb_stdout);
2020 x86_cleanup_dregs ();
2021 inferior_ptid = null_ptid;
2022 detach_inferior (inf);
2024 maybe_unpush_target ();
2027 /* Try to determine the executable filename.
2029 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.
2031 Upon success, the filename is stored inside EXE_NAME_RET, and
2032 this function returns nonzero.
2034 Otherwise, this function returns zero and the contents of
2035 EXE_NAME_RET is undefined. */
2038 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
2045 if (!EnumProcessModules (current_process_handle, &dh_buf,
2046 sizeof (HMODULE), &cbNeeded) || !cbNeeded)
2049 /* We know the executable is always first in the list of modules,
2050 which we just fetched. So no need to fetch more. */
2054 /* Cygwin prefers that the path be in /x/y/z format, so extract
2055 the filename into a temporary buffer first, and then convert it
2056 to POSIX format into the destination buffer. */
2057 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t));
2059 len = GetModuleFileNameEx (current_process_handle,
2060 dh_buf, pathbuf, exe_name_max_len);
2062 error (_("Error getting executable filename: %u."),
2063 (unsigned) GetLastError ());
2064 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
2065 exe_name_max_len) < 0)
2066 error (_("Error converting executable filename to POSIX: %d."), errno);
2069 len = GetModuleFileNameEx (current_process_handle,
2070 dh_buf, exe_name_ret, exe_name_max_len);
2072 error (_("Error getting executable filename: %u."),
2073 (unsigned) GetLastError ());
2076 return 1; /* success */
2079 /* The pid_to_exec_file target_ops method for this platform. */
2082 windows_nat_target::pid_to_exec_file (int pid)
2084 static char path[__PMAX];
2086 /* Try to find exe name as symlink target of /proc/<pid>/exe. */
2088 char procexe[sizeof ("/proc/4294967295/exe")];
2090 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
2091 nchars = readlink (procexe, path, sizeof(path));
2092 if (nchars > 0 && nchars < sizeof (path))
2094 path[nchars] = '\0'; /* Got it */
2099 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
2100 of gdb, or we're trying to debug a non-Cygwin windows executable. */
2101 if (!windows_get_exec_module_filename (path, sizeof (path)))
2107 /* Print status information about what we're accessing. */
2110 windows_nat_target::files_info ()
2112 struct inferior *inf = current_inferior ();
2114 printf_unfiltered ("\tUsing the running image of %s %s.\n",
2115 inf->attach_flag ? "attached" : "child",
2116 target_pid_to_str (inferior_ptid));
2119 /* Modify CreateProcess parameters for use of a new separate console.
2121 *FLAGS: DWORD parameter for general process creation flags.
2122 *SI: STARTUPINFO structure, for which the console window size and
2123 console buffer size is filled in if GDB is running in a console.
2124 to create the new console.
2125 The size of the used font is not available on all versions of
2126 Windows OS. Furthermore, the current font might not be the default
2127 font, but this is still better than before.
2128 If the windows and buffer sizes are computed,
2129 SI->DWFLAGS is changed so that this information is used
2130 by CreateProcess function. */
2133 windows_set_console_info (STARTUPINFO *si, DWORD *flags)
2135 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
2136 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2138 if (hconsole != INVALID_HANDLE_VALUE)
2140 CONSOLE_SCREEN_BUFFER_INFO sbinfo;
2142 CONSOLE_FONT_INFO cfi;
2144 GetCurrentConsoleFont (hconsole, FALSE, &cfi);
2145 font_size = GetConsoleFontSize (hconsole, cfi.nFont);
2146 GetConsoleScreenBufferInfo(hconsole, &sbinfo);
2147 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
2148 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
2150 si->dwXSize *= font_size.X;
2154 si->dwYSize *= font_size.Y;
2157 si->dwXCountChars = sbinfo.dwSize.X;
2158 si->dwYCountChars = sbinfo.dwSize.Y;
2159 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
2161 *flags |= CREATE_NEW_CONSOLE;
2165 /* Function called by qsort to sort environment strings. */
2168 envvar_cmp (const void *a, const void *b)
2170 const char **p = (const char **) a;
2171 const char **q = (const char **) b;
2172 return strcasecmp (*p, *q);
2178 clear_win32_environment (char **env)
2182 wchar_t *copy = NULL, *equalpos;
2184 for (i = 0; env[i] && *env[i]; i++)
2186 len = mbstowcs (NULL, env[i], 0) + 1;
2187 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
2188 mbstowcs (copy, env[i], len);
2189 equalpos = wcschr (copy, L'=');
2192 SetEnvironmentVariableW (copy, NULL);
2200 /* Redirection of inferior I/O streams for native MS-Windows programs.
2201 Unlike on Unix, where this is handled by invoking the inferior via
2202 the shell, on MS-Windows we need to emulate the cmd.exe shell.
2204 The official documentation of the cmd.exe redirection features is here:
2206 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx
2208 (That page talks about Windows XP, but there's no newer
2209 documentation, so we assume later versions of cmd.exe didn't change
2212 Caveat: the documentation on that page seems to include a few lies.
2213 For example, it describes strange constructs 1<&2 and 2<&1, which
2214 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I
2215 think the cmd.exe parser of the redirection symbols simply doesn't
2216 care about the < vs > distinction in these cases. Therefore, the
2217 supported features are explicitly documented below.
2219 The emulation below aims at supporting all the valid use cases
2220 supported by cmd.exe, which include:
2222 < FILE redirect standard input from FILE
2223 0< FILE redirect standard input from FILE
2224 <&N redirect standard input from file descriptor N
2225 0<&N redirect standard input from file descriptor N
2226 > FILE redirect standard output to FILE
2227 >> FILE append standard output to FILE
2228 1>> FILE append standard output to FILE
2229 >&N redirect standard output to file descriptor N
2230 1>&N redirect standard output to file descriptor N
2231 >>&N append standard output to file descriptor N
2232 1>>&N append standard output to file descriptor N
2233 2> FILE redirect standard error to FILE
2234 2>> FILE append standard error to FILE
2235 2>&N redirect standard error to file descriptor N
2236 2>>&N append standard error to file descriptor N
2238 Note that using N > 2 in the above construct is supported, but
2239 requires that the corresponding file descriptor be open by some
2240 means elsewhere or outside GDB. Also note that using ">&0" or
2241 "<&2" will generally fail, because the file descriptor redirected
2242 from is normally open in an incompatible mode (e.g., FD 0 is open
2243 for reading only). IOW, use of such tricks is not recommended;
2244 you are on your own.
2246 We do NOT support redirection of file descriptors above 2, as in
2247 "3>SOME-FILE", because MinGW compiled programs don't (supporting
2248 that needs special handling in the startup code that MinGW
2249 doesn't have). Pipes are also not supported.
2251 As for invalid use cases, where the redirection contains some
2252 error, the emulation below will detect that and produce some
2253 error and/or failure. But the behavior in those cases is not
2254 bug-for-bug compatible with what cmd.exe does in those cases.
2255 That's because what cmd.exe does then is not well defined, and
2256 seems to be a side effect of the cmd.exe parsing of the command
2257 line more than anything else. For example, try redirecting to an
2258 invalid file name, as in "> foo:bar".
2260 There are also minor syntactic deviations from what cmd.exe does
2261 in some corner cases. For example, it doesn't support the likes
2262 of "> &foo" to mean redirect to file named literally "&foo"; we
2263 do support that here, because that, too, sounds like some issue
2264 with the cmd.exe parser. Another nicety is that we support
2265 redirection targets that use file names with forward slashes,
2266 something cmd.exe doesn't -- this comes in handy since GDB
2267 file-name completion can be used when typing the command line for
2270 /* Support routines for redirecting standard handles of the inferior. */
2272 /* Parse a single redirection spec, open/duplicate the specified
2273 file/fd, and assign the appropriate value to one of the 3 standard
2274 file descriptors. */
2276 redir_open (const char *redir_string, int *inp, int *out, int *err)
2278 int *fd, ref_fd = -2;
2280 const char *fname = redir_string + 1;
2281 int rc = *redir_string;
2296 fd = (rc == '2') ? err : out;
2297 mode = O_WRONLY | O_CREAT;
2310 if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9')
2312 /* A reference to a file descriptor. */
2314 ref_fd = (int) strtol (fname + 1, &fdtail, 10);
2315 if (fdtail > fname + 1 && *fdtail == '\0')
2317 /* Don't allow redirection when open modes are incompatible. */
2318 if ((ref_fd == 0 && (fd == out || fd == err))
2319 || ((ref_fd == 1 || ref_fd == 2) && fd == inp))
2326 else if (ref_fd == 1)
2328 else if (ref_fd == 2)
2338 fname++; /* skip the separator space */
2339 /* If the descriptor is already open, close it. This allows
2340 multiple specs of redirections for the same stream, which is
2341 somewhat nonsensical, but still valid and supported by cmd.exe.
2342 (But cmd.exe only opens a single file in this case, the one
2343 specified by the last redirection spec on the command line.) */
2348 *fd = _open (fname, mode, _S_IREAD | _S_IWRITE);
2352 else if (ref_fd == -1)
2353 *fd = -1; /* reset to default destination */
2356 *fd = _dup (ref_fd);
2360 /* _open just sets a flag for O_APPEND, which won't be passed to the
2361 inferior, so we need to actually move the file pointer. */
2362 if ((mode & O_APPEND) != 0)
2363 _lseek (*fd, 0L, SEEK_END);
2367 /* Canonicalize a single redirection spec and set up the corresponding
2368 file descriptor as specified. */
2370 redir_set_redirection (const char *s, int *inp, int *out, int *err)
2372 char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */
2374 const char *start = s;
2377 *d++ = *s++; /* copy the 1st character, < or > or a digit */
2378 if ((*start == '>' || *start == '1' || *start == '2')
2382 if (*s == '>' && *start != '>')
2385 else if (*start == '0' && *s == '<')
2387 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */
2390 while (isspace (*s)) /* skip whitespace before file name */
2392 *d++ = ' '; /* separate file name with a single space */
2395 /* Copy the file name. */
2398 /* Remove quoting characters from the file name in buf[]. */
2399 if (*s == '"') /* could support '..' quoting here */
2403 else if (*s == quote)
2411 else if (*s == '\\')
2413 if (s[1] == '"') /* could support '..' here */
2417 else if (isspace (*s) && !quote)
2421 if (d - buf >= sizeof (buf) - 1)
2423 errno = ENAMETOOLONG;
2429 /* Windows doesn't allow redirection characters in file names, so we
2430 can bail out early if they use them, or if there's no target file
2431 name after the redirection symbol. */
2432 if (d[-1] == '>' || d[-1] == '<')
2437 if (redir_open (buf, inp, out, err) == 0)
2442 /* Parse the command line for redirection specs and prepare the file
2443 descriptors for the 3 standard streams accordingly. */
2445 redirect_inferior_handles (const char *cmd_orig, char *cmd,
2446 int *inp, int *out, int *err)
2448 const char *s = cmd_orig;
2451 bool retval = false;
2453 while (isspace (*s))
2458 if (*s == '"') /* could also support '..' quoting here */
2462 else if (*s == quote)
2465 else if (*s == '\\')
2467 if (s[1] == '"') /* escaped quote char */
2472 /* Process a single redirection candidate. */
2473 if (*s == '<' || *s == '>'
2474 || ((*s == '1' || *s == '2') && s[1] == '>')
2475 || (*s == '0' && s[1] == '<'))
2477 int skip = redir_set_redirection (s, inp, out, err);
2491 #endif /* !__CYGWIN__ */
2493 /* Start an inferior windows child process and sets inferior_ptid to its pid.
2494 EXEC_FILE is the file to run.
2495 ALLARGS is a string containing the arguments to the program.
2496 ENV is the environment vector to pass. Errors reported with error(). */
2499 windows_nat_target::create_inferior (const char *exec_file,
2500 const std::string &origallargs,
2501 char **in_env, int from_tty)
2505 cygwin_buf_t real_path[__PMAX];
2506 cygwin_buf_t shell[__PMAX]; /* Path to shell */
2507 cygwin_buf_t infcwd[__PMAX];
2509 cygwin_buf_t *toexec;
2510 cygwin_buf_t *cygallargs;
2512 char **old_env = NULL;
2516 int ostdin, ostdout, ostderr;
2517 #else /* !__CYGWIN__ */
2518 char shell[__PMAX]; /* Path to shell */
2520 char *args, *allargs_copy;
2521 size_t args_len, allargs_len;
2522 int fd_inp = -1, fd_out = -1, fd_err = -1;
2523 HANDLE tty = INVALID_HANDLE_VALUE;
2524 bool redirected = false;
2531 #endif /* !__CYGWIN__ */
2532 const char *allargs = origallargs.c_str ();
2533 PROCESS_INFORMATION pi;
2536 const char *inferior_io_terminal = get_inferior_io_terminal ();
2539 error (_("No executable specified, use `target exec'."));
2541 const char *inferior_cwd = get_inferior_cwd ();
2542 std::string expanded_infcwd;
2543 if (inferior_cwd != NULL)
2545 expanded_infcwd = gdb_tilde_expand (inferior_cwd);
2546 /* Mirror slashes on inferior's cwd. */
2547 std::replace (expanded_infcwd.begin (), expanded_infcwd.end (),
2549 inferior_cwd = expanded_infcwd.c_str ();
2552 memset (&si, 0, sizeof (si));
2553 si.cb = sizeof (si);
2556 flags |= CREATE_NEW_PROCESS_GROUP;
2559 windows_set_console_info (&si, &flags);
2564 flags |= DEBUG_ONLY_THIS_PROCESS;
2565 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
2566 __PMAX * sizeof (cygwin_buf_t)) < 0)
2567 error (_("Error starting executable: %d"), errno);
2570 len = mbstowcs (NULL, allargs, 0) + 1;
2571 if (len == (size_t) -1)
2572 error (_("Error starting executable: %d"), errno);
2573 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2574 mbstowcs (cygallargs, allargs, len);
2575 #else /* !__USEWIDE */
2576 cygallargs = allargs;
2581 sh = getenv ("SHELL");
2584 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
2585 error (_("Error starting executable via shell: %d"), errno);
2587 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0)
2588 + mbstowcs (NULL, allargs, 0) + 2;
2589 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
2590 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
2591 #else /* !__USEWIDE */
2592 len = (sizeof (" -c 'exec '") + strlen (exec_file)
2593 + strlen (allargs) + 2);
2594 cygallargs = (char *) alloca (len);
2595 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
2596 #endif /* __USEWIDE */
2598 flags |= DEBUG_PROCESS;
2601 if (inferior_cwd != NULL
2602 && cygwin_conv_path (CCP_POSIX_TO_WIN_W, inferior_cwd,
2603 infcwd, strlen (inferior_cwd)) < 0)
2604 error (_("Error converting inferior cwd: %d"), errno);
2607 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
2608 * sizeof (wchar_t));
2609 wcscpy (args, toexec);
2610 wcscat (args, L" ");
2611 wcscat (args, cygallargs);
2612 #else /* !__USEWIDE */
2613 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
2614 strcpy (args, toexec);
2616 strcat (args, cygallargs);
2617 #endif /* !__USEWIDE */
2619 #ifdef CW_CVT_ENV_TO_WINENV
2620 /* First try to create a direct Win32 copy of the POSIX environment. */
2621 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
2622 if (w32_env != (PWCHAR) -1)
2623 flags |= CREATE_UNICODE_ENVIRONMENT;
2625 /* If that fails, fall back to old method tweaking GDB's environment. */
2626 #endif /* CW_CVT_ENV_TO_WINENV */
2628 /* Reset all Win32 environment variables to avoid leftover on next run. */
2629 clear_win32_environment (environ);
2630 /* Prepare the environment vars for CreateProcess. */
2633 cygwin_internal (CW_SYNC_WINENV);
2637 if (!inferior_io_terminal)
2638 tty = ostdin = ostdout = ostderr = -1;
2641 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
2644 print_sys_errmsg (inferior_io_terminal, errno);
2645 ostdin = ostdout = ostderr = -1;
2658 windows_init_thread_list ();
2659 ret = CreateProcess (0,
2660 args, /* command line */
2661 NULL, /* Security */
2663 TRUE, /* inherit handles */
2664 flags, /* start flags */
2665 w32_env, /* environment */
2666 inferior_cwd != NULL ? infcwd : NULL, /* current
2671 /* Just free the Win32 environment, if it could be created. */
2675 /* Reset all environment variables to avoid leftover on next run. */
2676 clear_win32_environment (in_env);
2677 /* Restore normal GDB environment variables. */
2679 cygwin_internal (CW_SYNC_WINENV);
2692 #else /* !__CYGWIN__ */
2693 allargs_len = strlen (allargs);
2694 allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs);
2695 if (strpbrk (allargs_copy, "<>") != NULL)
2700 redirect_inferior_handles (allargs, allargs_copy,
2701 &fd_inp, &fd_out, &fd_err);
2703 warning (_("Error in redirection: %s."), strerror (errno));
2706 allargs_len = strlen (allargs_copy);
2708 /* If not all the standard streams are redirected by the command
2709 line, use inferior_io_terminal for those which aren't. */
2710 if (inferior_io_terminal
2711 && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0))
2713 SECURITY_ATTRIBUTES sa;
2714 sa.nLength = sizeof(sa);
2715 sa.lpSecurityDescriptor = 0;
2716 sa.bInheritHandle = TRUE;
2717 tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
2718 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2719 if (tty == INVALID_HANDLE_VALUE)
2720 warning (_("Warning: Failed to open TTY %s, error %#x."),
2721 inferior_io_terminal, (unsigned) GetLastError ());
2723 if (redirected || tty != INVALID_HANDLE_VALUE)
2726 si.hStdInput = (HANDLE) _get_osfhandle (fd_inp);
2727 else if (tty != INVALID_HANDLE_VALUE)
2730 si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
2732 si.hStdOutput = (HANDLE) _get_osfhandle (fd_out);
2733 else if (tty != INVALID_HANDLE_VALUE)
2734 si.hStdOutput = tty;
2736 si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
2738 si.hStdError = (HANDLE) _get_osfhandle (fd_err);
2739 else if (tty != INVALID_HANDLE_VALUE)
2742 si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
2743 si.dwFlags |= STARTF_USESTDHANDLES;
2747 /* Build the command line, a space-separated list of tokens where
2748 the first token is the name of the module to be executed.
2749 To avoid ambiguities introduced by spaces in the module name,
2751 args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2;
2752 args = (char *) alloca (args_len);
2753 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy);
2755 flags |= DEBUG_ONLY_THIS_PROCESS;
2757 /* CreateProcess takes the environment list as a null terminated set of
2758 strings (i.e. two nulls terminate the list). */
2760 /* Get total size for env strings. */
2761 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
2762 envlen += strlen (in_env[i]) + 1;
2764 envsize = sizeof (in_env[0]) * (i + 1);
2765 env = (char **) alloca (envsize);
2766 memcpy (env, in_env, envsize);
2767 /* Windows programs expect the environment block to be sorted. */
2768 qsort (env, i, sizeof (char *), envvar_cmp);
2770 w32env = (char *) alloca (envlen + 1);
2772 /* Copy env strings into new buffer. */
2773 for (temp = w32env, i = 0; env[i] && *env[i]; i++)
2775 strcpy (temp, env[i]);
2776 temp += strlen (temp) + 1;
2779 /* Final nil string to terminate new env. */
2782 windows_init_thread_list ();
2783 ret = CreateProcessA (0,
2784 args, /* command line */
2785 NULL, /* Security */
2787 TRUE, /* inherit handles */
2788 flags, /* start flags */
2789 w32env, /* environment */
2790 inferior_cwd, /* current directory */
2793 if (tty != INVALID_HANDLE_VALUE)
2801 #endif /* !__CYGWIN__ */
2804 error (_("Error creating process %s, (error %u)."),
2805 exec_file, (unsigned) GetLastError ());
2807 CloseHandle (pi.hThread);
2808 CloseHandle (pi.hProcess);
2810 if (useshell && shell[0] != '\0')
2815 do_initial_windows_stuff (this, pi.dwProcessId, 0);
2817 /* windows_continue (DBG_CONTINUE, -1, 0); */
2821 windows_nat_target::mourn_inferior ()
2823 (void) windows_continue (DBG_CONTINUE, -1, 0);
2824 x86_cleanup_dregs();
2825 if (open_process_used)
2827 CHECK (CloseHandle (current_process_handle));
2828 open_process_used = 0;
2830 inf_child_target::mourn_inferior ();
2833 /* Send a SIGINT to the process group. This acts just like the user typed a
2834 ^C on the controlling terminal. */
2837 windows_nat_target::interrupt ()
2839 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2840 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
2841 registers_changed (); /* refresh register state */
2844 /* Helper for windows_xfer_partial that handles memory transfers.
2845 Arguments are like target_xfer_partial. */
2847 static enum target_xfer_status
2848 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2849 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2853 DWORD lasterror = 0;
2855 if (writebuf != NULL)
2857 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
2858 pulongest (len), core_addr_to_string (memaddr)));
2859 success = WriteProcessMemory (current_process_handle,
2860 (LPVOID) (uintptr_t) memaddr, writebuf,
2863 lasterror = GetLastError ();
2864 FlushInstructionCache (current_process_handle,
2865 (LPCVOID) (uintptr_t) memaddr, len);
2869 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
2870 pulongest (len), core_addr_to_string (memaddr)));
2871 success = ReadProcessMemory (current_process_handle,
2872 (LPCVOID) (uintptr_t) memaddr, readbuf,
2875 lasterror = GetLastError ();
2877 *xfered_len = (ULONGEST) done;
2878 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
2879 return TARGET_XFER_OK;
2881 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
2885 windows_nat_target::kill ()
2887 CHECK (TerminateProcess (current_process_handle, 0));
2891 if (!windows_continue (DBG_CONTINUE, -1, 1))
2893 if (!WaitForDebugEvent (¤t_event, INFINITE))
2895 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2899 target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */
2903 windows_nat_target::close ()
2905 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2906 inferior_ptid.pid ()));
2909 /* Convert pid to printable format. */
2911 windows_nat_target::pid_to_str (ptid_t ptid)
2913 static char buf[80];
2915 if (ptid.tid () != 0)
2917 snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2918 ptid.pid (), ptid.tid ());
2922 return normal_pid_to_str (ptid);
2925 static enum target_xfer_status
2926 windows_xfer_shared_libraries (struct target_ops *ops,
2927 enum target_object object, const char *annex,
2928 gdb_byte *readbuf, const gdb_byte *writebuf,
2929 ULONGEST offset, ULONGEST len,
2930 ULONGEST *xfered_len)
2932 struct obstack obstack;
2938 return TARGET_XFER_E_IO;
2940 obstack_init (&obstack);
2941 obstack_grow_str (&obstack, "<library-list>\n");
2942 for (so = solib_start.next; so; so = so->next)
2944 lm_info_windows *li = (lm_info_windows *) so->lm_info;
2946 windows_xfer_shared_library (so->so_name, (CORE_ADDR)
2947 (uintptr_t) li->load_addr,
2948 target_gdbarch (), &obstack);
2950 obstack_grow_str0 (&obstack, "</library-list>\n");
2952 buf = (const char *) obstack_finish (&obstack);
2953 len_avail = strlen (buf);
2954 if (offset >= len_avail)
2958 if (len > len_avail - offset)
2959 len = len_avail - offset;
2960 memcpy (readbuf, buf + offset, len);
2963 obstack_free (&obstack, NULL);
2964 *xfered_len = (ULONGEST) len;
2965 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
2968 enum target_xfer_status
2969 windows_nat_target::xfer_partial (enum target_object object,
2970 const char *annex, gdb_byte *readbuf,
2971 const gdb_byte *writebuf, ULONGEST offset,
2972 ULONGEST len, ULONGEST *xfered_len)
2976 case TARGET_OBJECT_MEMORY:
2977 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2979 case TARGET_OBJECT_LIBRARIES:
2980 return windows_xfer_shared_libraries (this, object, annex, readbuf,
2981 writebuf, offset, len, xfered_len);
2984 if (beneath () == NULL)
2986 /* This can happen when requesting the transfer of unsupported
2987 objects before a program has been started (and therefore
2988 with the current_target having no target beneath). */
2989 return TARGET_XFER_E_IO;
2991 return beneath ()->xfer_partial (object, annex,
2992 readbuf, writebuf, offset, len,
2997 /* Provide thread local base, i.e. Thread Information Block address.
2998 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */
3001 windows_nat_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
3003 windows_thread_info *th;
3005 th = thread_rec (ptid.tid (), 0);
3010 *addr = th->thread_local_base;
3016 windows_nat_target::get_ada_task_ptid (long lwp, long thread)
3018 return ptid_t (inferior_ptid.pid (), 0, lwp);
3021 /* Implementation of the to_thread_name method. */
3024 windows_nat_target::thread_name (struct thread_info *thr)
3026 return thread_rec (thr->ptid.tid (), 0)->name;
3031 _initialize_windows_nat (void)
3033 x86_dr_low.set_control = cygwin_set_dr7;
3034 x86_dr_low.set_addr = cygwin_set_dr;
3035 x86_dr_low.get_addr = cygwin_get_dr;
3036 x86_dr_low.get_status = cygwin_get_dr6;
3037 x86_dr_low.get_control = cygwin_get_dr7;
3039 /* x86_dr_low.debug_register_length field is set by
3040 calling x86_set_debug_register_length function
3041 in processor windows specific native file. */
3043 add_inf_child_target (&the_windows_nat_target);
3046 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
3049 add_com ("signal-event", class_run, signal_event_command, _("\
3050 Signal a crashed process with event ID, to allow its debugging.\n\
3051 This command is needed in support of setting up GDB as JIT debugger on \
3052 MS-Windows. The command should be invoked from the GDB command line using \
3053 the '-ex' command-line option. The ID of the event that blocks the \
3054 crashed process will be supplied by the Windows JIT debugging mechanism."));
3057 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
3058 Set use of shell to start subprocess."), _("\
3059 Show use of shell to start subprocess."), NULL,
3061 NULL, /* FIXME: i18n: */
3062 &setlist, &showlist);
3064 add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
3065 &cygwin_exceptions, _("\
3066 Break when an exception is detected in the Cygwin DLL itself."), _("\
3067 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
3069 NULL, /* FIXME: i18n: */
3070 &setlist, &showlist);
3073 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
3074 Set creation of new console when creating child process."), _("\
3075 Show creation of new console when creating child process."), NULL,
3077 NULL, /* FIXME: i18n: */
3078 &setlist, &showlist);
3080 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
3081 Set creation of new group when creating child process."), _("\
3082 Show creation of new group when creating child process."), NULL,
3084 NULL, /* FIXME: i18n: */
3085 &setlist, &showlist);
3087 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
3088 Set whether to display execution in child process."), _("\
3089 Show whether to display execution in child process."), NULL,
3091 NULL, /* FIXME: i18n: */
3092 &setlist, &showlist);
3094 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
3095 Set whether to display kernel events in child process."), _("\
3096 Show whether to display kernel events in child process."), NULL,
3098 NULL, /* FIXME: i18n: */
3099 &setlist, &showlist);
3101 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
3102 Set whether to display memory accesses in child process."), _("\
3103 Show whether to display memory accesses in child process."), NULL,
3105 NULL, /* FIXME: i18n: */
3106 &setlist, &showlist);
3108 add_setshow_boolean_cmd ("debugexceptions", class_support,
3109 &debug_exceptions, _("\
3110 Set whether to display kernel exceptions in child process."), _("\
3111 Show whether to display kernel exceptions in child process."), NULL,
3113 NULL, /* FIXME: i18n: */
3114 &setlist, &showlist);
3116 init_w32_command_list ();
3118 add_cmd ("selector", class_info, display_selectors,
3119 _("Display selectors infos."),
3123 /* Hardware watchpoint support, adapted from go32-nat.c code. */
3125 /* Pass the address ADDR to the inferior in the I'th debug register.
3126 Here we just store the address in dr array, the registers will be
3127 actually set up when windows_continue is called. */
3129 cygwin_set_dr (int i, CORE_ADDR addr)
3132 internal_error (__FILE__, __LINE__,
3133 _("Invalid register %d in cygwin_set_dr.\n"), i);
3135 debug_registers_changed = 1;
3136 debug_registers_used = 1;
3139 /* Pass the value VAL to the inferior in the DR7 debug control
3140 register. Here we just store the address in D_REGS, the watchpoint
3141 will be actually set up in windows_wait. */
3143 cygwin_set_dr7 (unsigned long val)
3145 dr[7] = (CORE_ADDR) val;
3146 debug_registers_changed = 1;
3147 debug_registers_used = 1;
3150 /* Get the value of debug register I from the inferior. */
3153 cygwin_get_dr (int i)
3158 /* Get the value of the DR6 debug status register from the inferior.
3159 Here we just return the value stored in dr[6]
3160 by the last call to thread_rec for current_event.dwThreadId id. */
3161 static unsigned long
3162 cygwin_get_dr6 (void)
3164 return (unsigned long) dr[6];
3167 /* Get the value of the DR7 debug status register from the inferior.
3168 Here we just return the value stored in dr[7] by the last call to
3169 thread_rec for current_event.dwThreadId id. */
3171 static unsigned long
3172 cygwin_get_dr7 (void)
3174 return (unsigned long) dr[7];
3177 /* Determine if the thread referenced by "ptid" is alive
3178 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
3179 it means that the thread has died. Otherwise it is assumed to be alive. */
3182 windows_nat_target::thread_alive (ptid_t ptid)
3186 gdb_assert (ptid.tid () != 0);
3189 return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) != WAIT_OBJECT_0;
3193 _initialize_check_for_gdb_ini (void)
3196 if (inhibit_gdbinit)
3199 homedir = getenv ("HOME");
3203 char *oldini = (char *) alloca (strlen (homedir) +
3204 sizeof ("gdb.ini") + 1);
3205 strcpy (oldini, homedir);
3206 p = strchr (oldini, '\0');
3207 if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
3209 strcpy (p, "gdb.ini");
3210 if (access (oldini, 0) == 0)
3212 int len = strlen (oldini);
3213 char *newini = (char *) alloca (len + 2);
3215 xsnprintf (newini, len + 2, "%.*s.gdbinit",
3216 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
3217 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
3222 /* Define dummy functions which always return error for the rare cases where
3223 these functions could not be found. */
3225 bad_DebugActiveProcessStop (DWORD w)
3230 bad_DebugBreakProcess (HANDLE w)
3235 bad_DebugSetProcessKillOnExit (BOOL w)
3240 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
3247 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
3253 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
3260 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
3266 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
3272 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
3278 bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
3286 /* Load any functions which may not be available in ancient versions
3290 _initialize_loadable (void)
3294 #define GPA(m, func) \
3295 func = (func ## _ftype *) GetProcAddress (m, #func)
3297 hm = LoadLibrary ("kernel32.dll");
3300 GPA (hm, DebugActiveProcessStop);
3301 GPA (hm, DebugBreakProcess);
3302 GPA (hm, DebugSetProcessKillOnExit);
3303 GPA (hm, GetConsoleFontSize);
3304 GPA (hm, DebugActiveProcessStop);
3305 GPA (hm, GetCurrentConsoleFont);
3308 /* Set variables to dummy versions of these processes if the function
3309 wasn't found in kernel32.dll. */
3310 if (!DebugBreakProcess)
3311 DebugBreakProcess = bad_DebugBreakProcess;
3312 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
3314 DebugActiveProcessStop = bad_DebugActiveProcessStop;
3315 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
3317 if (!GetConsoleFontSize)
3318 GetConsoleFontSize = bad_GetConsoleFontSize;
3319 if (!GetCurrentConsoleFont)
3320 GetCurrentConsoleFont = bad_GetCurrentConsoleFont;
3322 /* Load optional functions used for retrieving filename information
3323 associated with the currently debugged process or its dlls. */
3324 hm = LoadLibrary ("psapi.dll");
3327 GPA (hm, EnumProcessModules);
3328 GPA (hm, GetModuleInformation);
3329 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *)
3330 GetProcAddress (hm, GetModuleFileNameEx_name);
3333 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
3335 /* Set variables to dummy versions of these processes if the function
3336 wasn't found in psapi.dll. */
3337 EnumProcessModules = bad_EnumProcessModules;
3338 GetModuleInformation = bad_GetModuleInformation;
3339 GetModuleFileNameEx = bad_GetModuleFileNameEx;
3340 /* This will probably fail on Windows 9x/Me. Let the user know
3341 that we're missing some functionality. */
3343 cannot automatically find executable file or library to read symbols.\n\
3344 Use \"file\" or \"dll\" command to load executable/libraries directly."));
3347 hm = LoadLibrary ("advapi32.dll");
3350 GPA (hm, OpenProcessToken);
3351 GPA (hm, LookupPrivilegeValueA);
3352 GPA (hm, AdjustTokenPrivileges);
3353 /* Only need to set one of these since if OpenProcessToken fails nothing
3355 if (!OpenProcessToken || !LookupPrivilegeValueA
3356 || !AdjustTokenPrivileges)
3357 OpenProcessToken = bad_OpenProcessToken;