1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Originally by Steve Chamberlain, sac@cygnus.com */
27 /* We assume we're being built with and will be used for cygwin. */
30 #include "frame.h" /* required by inferior.h */
35 #include "completer.h"
39 #include <sys/types.h>
44 #include <sys/cygwin.h>
49 #include "gdb_string.h"
50 #include "gdbthread.h"
52 #include <sys/param.h>
56 #include "i386-tdep.h"
57 #include "i387-tdep.h"
59 /* If we're not using the old Cygwin header file set, define the
60 following which never should have been in the generic Win32 API
61 headers in the first place since they were our own invention... */
62 #ifndef _GNU_H_WINDOWS_H
65 FLAG_TRACE_BIT = 0x100,
66 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
69 #include <sys/procfs.h>
72 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
73 | CONTEXT_EXTENDED_REGISTERS
75 static unsigned dr[8];
76 static int debug_registers_changed;
77 static int debug_registers_used;
79 /* The string sent by cygwin when it processes a signal.
80 FIXME: This should be in a cygwin include file. */
81 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
83 #define CHECK(x) check (x, __FILE__,__LINE__)
84 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
85 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
86 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
87 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
89 /* Forward declaration */
90 extern struct target_ops child_ops;
92 static void child_stop (void);
93 static int win32_child_thread_alive (ptid_t);
94 void child_kill_inferior (void);
96 static enum target_signal last_sig = TARGET_SIGNAL_0;
97 /* Set if a signal was received from the debugged process */
99 /* Thread information structure used to track information that is
100 not available in gdb's thread structure. */
101 typedef struct thread_info_struct
103 struct thread_info_struct *next;
114 static thread_info thread_head;
116 /* The process and thread handles for the above context. */
118 static DEBUG_EVENT current_event; /* The current debug event from
120 static HANDLE current_process_handle; /* Currently executing process */
121 static thread_info *current_thread; /* Info on currently selected thread */
122 static DWORD main_thread_id; /* Thread ID of the main thread */
124 /* Counts of things. */
125 static int exception_count = 0;
126 static int event_count = 0;
127 static int saw_create;
130 static int new_console = 0;
131 static int new_group = 1;
132 static int debug_exec = 0; /* show execution */
133 static int debug_events = 0; /* show events from kernel */
134 static int debug_memory = 0; /* show target memory accesses */
135 static int debug_exceptions = 0; /* show target exceptions */
136 static int useshell = 0; /* use shell for subprocesses */
138 /* This vector maps GDB's idea of a register's number into an address
139 in the win32 exception context vector.
141 It also contains the bit mask needed to load the register in question.
143 One day we could read a reg, we could inspect the context we
144 already have loaded, if it doesn't have the bit set that we need,
145 we read that set of registers in using GetThreadContext. If the
146 context already contains what we need, we just unpack it. Then to
147 write a register, first we have to ensure that the context contains
148 the other regs of the group, and then we copy the info in and set
151 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
152 static const int mappings[] =
154 context_offset (Eax),
155 context_offset (Ecx),
156 context_offset (Edx),
157 context_offset (Ebx),
158 context_offset (Esp),
159 context_offset (Ebp),
160 context_offset (Esi),
161 context_offset (Edi),
162 context_offset (Eip),
163 context_offset (EFlags),
164 context_offset (SegCs),
165 context_offset (SegSs),
166 context_offset (SegDs),
167 context_offset (SegEs),
168 context_offset (SegFs),
169 context_offset (SegGs),
170 context_offset (FloatSave.RegisterArea[0 * 10]),
171 context_offset (FloatSave.RegisterArea[1 * 10]),
172 context_offset (FloatSave.RegisterArea[2 * 10]),
173 context_offset (FloatSave.RegisterArea[3 * 10]),
174 context_offset (FloatSave.RegisterArea[4 * 10]),
175 context_offset (FloatSave.RegisterArea[5 * 10]),
176 context_offset (FloatSave.RegisterArea[6 * 10]),
177 context_offset (FloatSave.RegisterArea[7 * 10]),
178 context_offset (FloatSave.ControlWord),
179 context_offset (FloatSave.StatusWord),
180 context_offset (FloatSave.TagWord),
181 context_offset (FloatSave.ErrorSelector),
182 context_offset (FloatSave.ErrorOffset),
183 context_offset (FloatSave.DataSelector),
184 context_offset (FloatSave.DataOffset),
185 context_offset (FloatSave.ErrorSelector)
187 context_offset (ExtendedRegisters[10*16]),
188 context_offset (ExtendedRegisters[11*16]),
189 context_offset (ExtendedRegisters[12*16]),
190 context_offset (ExtendedRegisters[13*16]),
191 context_offset (ExtendedRegisters[14*16]),
192 context_offset (ExtendedRegisters[15*16]),
193 context_offset (ExtendedRegisters[16*16]),
194 context_offset (ExtendedRegisters[17*16]),
196 context_offset (ExtendedRegisters[24])
199 #undef context_offset
201 /* This vector maps the target's idea of an exception (extracted
202 from the DEBUG_EVENT structure) to GDB's idea. */
204 struct xlate_exception
207 enum target_signal us;
210 static const struct xlate_exception
213 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
214 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
215 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
216 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
217 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
218 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
222 check (BOOL ok, const char *file, int line)
225 printf_filtered ("error return %s:%d was %lu\n", file, line,
229 /* Find a thread record given a thread id.
230 If get_context then also retrieve the context for this
233 thread_rec (DWORD id, int get_context)
237 for (th = &thread_head; (th = th->next) != NULL;)
240 if (!th->suspend_count && get_context)
242 if (get_context > 0 && id != current_event.dwThreadId)
243 th->suspend_count = SuspendThread (th->h) + 1;
244 else if (get_context < 0)
245 th->suspend_count = -1;
246 th->reload_context = 1;
254 /* Add a thread to the thread list */
256 child_add_thread (DWORD id, HANDLE h)
260 if ((th = thread_rec (id, FALSE)))
263 th = (thread_info *) xmalloc (sizeof (*th));
264 memset (th, 0, sizeof (*th));
267 th->next = thread_head.next;
268 thread_head.next = th;
269 add_thread (pid_to_ptid (id));
270 /* Set the debug registers for the new thread in they are used. */
271 if (debug_registers_used)
273 /* Only change the value of the debug registers. */
274 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
275 CHECK (GetThreadContext (th->h, &th->context));
276 th->context.Dr0 = dr[0];
277 th->context.Dr1 = dr[1];
278 th->context.Dr2 = dr[2];
279 th->context.Dr3 = dr[3];
280 /* th->context.Dr6 = dr[6];
281 FIXME: should we set dr6 also ?? */
282 th->context.Dr7 = dr[7];
283 CHECK (SetThreadContext (th->h, &th->context));
284 th->context.ContextFlags = 0;
289 /* Clear out any old thread list and reintialize it to a
292 child_init_thread_list (void)
294 thread_info *th = &thread_head;
296 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
298 while (th->next != NULL)
300 thread_info *here = th->next;
301 th->next = here->next;
302 (void) CloseHandle (here->h);
307 /* Delete a thread from the list of threads */
309 child_delete_thread (DWORD id)
314 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
315 delete_thread (pid_to_ptid (id));
317 for (th = &thread_head;
318 th->next != NULL && th->next->id != id;
322 if (th->next != NULL)
324 thread_info *here = th->next;
325 th->next = here->next;
326 CloseHandle (here->h);
332 do_child_fetch_inferior_registers (int r)
334 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
338 return; /* Windows sometimes uses a non-existent thread id in its
341 if (current_thread->reload_context)
343 thread_info *th = current_thread;
344 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
345 GetThreadContext (th->h, &th->context);
346 /* Copy dr values from that thread. */
347 dr[0] = th->context.Dr0;
348 dr[1] = th->context.Dr1;
349 dr[2] = th->context.Dr2;
350 dr[3] = th->context.Dr3;
351 dr[6] = th->context.Dr6;
352 dr[7] = th->context.Dr7;
353 current_thread->reload_context = 0;
356 #define I387_ST0_REGNUM I386_ST0_REGNUM
358 if (r == I387_FISEG_REGNUM)
360 l = *((long *) context_offset) & 0xffff;
361 regcache_raw_supply (current_regcache, r, (char *) &l);
363 else if (r == I387_FOP_REGNUM)
365 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
366 regcache_raw_supply (current_regcache, r, (char *) &l);
369 regcache_raw_supply (current_regcache, r, context_offset);
372 for (r = 0; r < NUM_REGS; r++)
373 do_child_fetch_inferior_registers (r);
376 #undef I387_ST0_REGNUM
380 child_fetch_inferior_registers (int r)
382 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
383 /* Check if current_thread exists. Windows sometimes uses a non-existent
384 thread id in its events */
386 do_child_fetch_inferior_registers (r);
390 do_child_store_inferior_registers (int r)
393 /* Windows sometimes uses a non-existent thread id in its events */;
395 regcache_raw_collect (current_regcache, r,
396 ((char *) ¤t_thread->context) + mappings[r]);
399 for (r = 0; r < NUM_REGS; r++)
400 do_child_store_inferior_registers (r);
404 /* Store a new register value into the current thread context */
406 child_store_inferior_registers (int r)
408 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
409 /* Check if current_thread exists. Windows sometimes uses a non-existent
410 thread id in its events */
412 do_child_store_inferior_registers (r);
415 static int psapi_loaded = 0;
416 static HMODULE psapi_module_handle = NULL;
417 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD, LPDWORD) = NULL;
418 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;
419 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;
422 psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)
428 HMODULE *DllHandle = dh_buf;
433 psapi_EnumProcessModules == NULL ||
434 psapi_GetModuleInformation == NULL ||
435 psapi_GetModuleFileNameExA == NULL)
440 psapi_module_handle = LoadLibrary ("psapi.dll");
441 if (!psapi_module_handle)
443 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
446 psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");
447 psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");
448 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,
449 "GetModuleFileNameExA");
450 if (psapi_EnumProcessModules == NULL ||
451 psapi_GetModuleInformation == NULL ||
452 psapi_GetModuleFileNameExA == NULL)
457 ok = (*psapi_EnumProcessModules) (current_process_handle,
462 if (!ok || !cbNeeded)
465 DllHandle = (HMODULE *) alloca (cbNeeded);
469 ok = (*psapi_EnumProcessModules) (current_process_handle,
476 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
478 if (!(*psapi_GetModuleInformation) (current_process_handle,
482 error ("Can't get module info");
484 len = (*psapi_GetModuleFileNameExA) (current_process_handle,
489 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
491 if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)
496 dll_name_ret[0] = '\0';
500 /* Encapsulate the information required in a call to
501 symbol_file_add_args */
502 struct safe_symbol_file_add_args
506 struct section_addr_info *addrs;
509 struct ui_file *err, *out;
513 /* Maintain a linked list of "so" information. */
516 struct so_stuff *next;
520 struct objfile *objfile;
522 } solib_start, *solib_end;
524 /* Call symbol_file_add with stderr redirected. We don't care if there
527 safe_symbol_file_add_stub (void *argv)
529 #define p ((struct safe_symbol_file_add_args *)argv)
530 struct so_stuff *so = &solib_start;
532 while ((so = so->next))
533 if (so->loaded && strcasecmp (so->name, p->name) == 0)
535 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
540 /* Restore gdb's stderr after calling symbol_file_add */
542 safe_symbol_file_add_cleanup (void *p)
544 #define sp ((struct safe_symbol_file_add_args *)p)
545 gdb_flush (gdb_stderr);
546 gdb_flush (gdb_stdout);
547 ui_file_delete (gdb_stderr);
548 ui_file_delete (gdb_stdout);
549 gdb_stderr = sp->err;
550 gdb_stdout = sp->out;
554 /* symbol_file_add wrapper that prevents errors from being displayed. */
555 static struct objfile *
556 safe_symbol_file_add (char *name, int from_tty,
557 struct section_addr_info *addrs,
558 int mainline, int flags)
560 struct safe_symbol_file_add_args p;
561 struct cleanup *cleanup;
563 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
567 gdb_flush (gdb_stderr);
568 gdb_flush (gdb_stdout);
569 gdb_stderr = ui_file_new ();
570 gdb_stdout = ui_file_new ();
572 p.from_tty = from_tty;
574 p.mainline = mainline;
576 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
578 do_cleanups (cleanup);
582 /* Remember the maximum DLL length for printing in info dll command. */
583 int max_dll_name_len;
586 register_loaded_dll (const char *name, DWORD load_addr)
589 char ppath[MAX_PATH + 1];
590 char buf[MAX_PATH + 1];
591 char cwd[MAX_PATH + 1];
593 WIN32_FIND_DATA w32_fd;
594 HANDLE h = FindFirstFile(name, &w32_fd);
595 MEMORY_BASIC_INFORMATION m;
598 if (h == INVALID_HANDLE_VALUE)
604 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
606 p = strrchr (buf, '\\');
609 SetCurrentDirectory (buf);
610 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
611 SetCurrentDirectory (cwd);
615 cygwin_conv_to_posix_path (buf, ppath);
616 so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);
618 so->load_addr = load_addr;
619 if (VirtualQueryEx (current_process_handle, (void *) load_addr, &m,
621 so->end_addr = (DWORD) m.AllocationBase + m.RegionSize;
623 so->end_addr = load_addr + 0x2000; /* completely arbitrary */
627 strcpy (so->name, ppath);
629 solib_end->next = so;
631 len = strlen (ppath);
632 if (len > max_dll_name_len)
633 max_dll_name_len = len;
637 get_image_name (HANDLE h, void *address, int unicode)
639 static char buf[(2 * MAX_PATH) + 1];
640 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
646 /* Attempt to read the name of the dll that was detected.
647 This is documented to work only when actively debugging
648 a program. It will not work for attached processes. */
652 /* See if we could read the address of a string, and that the
653 address isn't null. */
654 if (!ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done)
655 || done != sizeof (address_ptr) || !address_ptr)
658 /* Find the length of the string */
659 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
660 && (b[0] != 0 || b[size - 1] != 0) && done == size)
664 ReadProcessMemory (h, address_ptr, buf, len, &done);
667 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
668 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
671 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
677 /* Wait for child to do something. Return pid of child, or -1 in case
678 of error; store status through argument pointer OURSTATUS. */
680 handle_load_dll (void *dummy)
682 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
683 char dll_buf[MAX_PATH + 1];
684 char *dll_name = NULL;
687 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
689 if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))
690 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
694 if (*dll_name == '\0')
695 dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode);
699 register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);
705 handle_unload_dll (void *dummy)
707 DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;
710 for (so = &solib_start; so->next != NULL; so = so->next)
711 if (so->next->load_addr == lpBaseOfDll)
713 struct so_stuff *sodel = so->next;
714 so->next = sodel->next;
718 free_objfile (sodel->objfile);
722 error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);
728 solib_address (CORE_ADDR address)
731 for (so = &solib_start; so->next != NULL; so = so->next)
732 if (address >= so->load_addr && address <= so->end_addr)
737 /* Return name of last loaded DLL. */
739 child_solib_loaded_library_pathname (int pid)
741 return !solib_end || !solib_end->name[0] ? NULL : solib_end->name;
744 /* Clear list of loaded DLLs. */
746 child_clear_solibs (void)
748 struct so_stuff *so, *so1 = solib_start.next;
750 while ((so = so1) != NULL)
756 solib_start.next = NULL;
757 solib_start.objfile = NULL;
758 solib_end = &solib_start;
759 max_dll_name_len = sizeof ("DLL Name") - 1;
762 /* Get the loaded address of all sections, given that .text was loaded
763 at text_load. Assumes that all sections are subject to the same
764 relocation offset. Returns NULL if problems occur or if the
765 sections were not relocated. */
767 static struct section_addr_info *
768 get_relocated_section_addrs (bfd *abfd, CORE_ADDR text_load)
770 struct section_addr_info *result = NULL;
771 int section_count = bfd_count_sections (abfd);
772 asection *text_section = bfd_get_section_by_name (abfd, ".text");
777 /* Couldn't get the .text section. Weird. */
780 else if (text_load == (text_vma = bfd_get_section_vma (abfd, text_section)))
782 /* DLL wasn't relocated. */
787 /* Figure out all sections' loaded addresses. The offset here is
788 such that taking a bfd_get_section_vma() result and adding
789 offset will give the real load address of the section. */
791 CORE_ADDR offset = text_load - text_vma;
793 struct section_table *table_start = NULL;
794 struct section_table *table_end = NULL;
795 struct section_table *iter = NULL;
797 build_section_table (abfd, &table_start, &table_end);
799 for (iter = table_start; iter < table_end; ++iter)
801 /* Relocated addresses. */
802 iter->addr += offset;
803 iter->endaddr += offset;
806 result = build_section_addr_info_from_section_table (table_start,
815 /* Add DLL symbol information. */
816 static struct objfile *
817 solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)
819 struct section_addr_info *addrs = NULL;
820 static struct objfile *result = NULL;
823 /* The symbols in a dll are offset by 0x1000, which is the
824 the offset from 0 of the first byte in an image - because
825 of the file header and the section alignment. */
827 if (!name || !name[0])
830 abfd = bfd_openr (name, "pei-i386");
834 /* pei failed - try pe */
835 abfd = bfd_openr (name, "pe-i386");
840 if (bfd_check_format (abfd, bfd_object))
842 addrs = get_relocated_section_addrs (abfd, load_addr);
850 result = safe_symbol_file_add (name, from_tty, addrs, 0, OBJF_SHARED);
851 free_section_addr_info (addrs);
855 /* Fallback on handling just the .text section. */
856 struct cleanup *my_cleanups;
858 addrs = alloc_section_addr_info (1);
859 my_cleanups = make_cleanup (xfree, addrs);
860 addrs->other[0].name = ".text";
861 addrs->other[0].addr = load_addr;
863 result = safe_symbol_file_add (name, from_tty, addrs, 0, OBJF_SHARED);
864 do_cleanups (my_cleanups);
870 /* Load DLL symbol info. */
872 dll_symbol_command (char *args, int from_tty)
878 error ("dll-symbols requires a file name");
881 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
883 char *newargs = (char *) alloca (n + 4 + 1);
884 strcpy (newargs, args);
885 strcat (newargs, ".dll");
889 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
892 /* List currently loaded DLLs. */
894 info_dll_command (char *ignore, int from_tty)
896 struct so_stuff *so = &solib_start;
901 printf_filtered ("%*s Load Address\n", -max_dll_name_len, "DLL Name");
902 while ((so = so->next) != NULL)
903 printf_filtered ("%*s %08lx\n", -max_dll_name_len, so->name, so->load_addr);
908 /* Handle DEBUG_STRING output from child process.
909 Cygwin prepends its messages with a "cygwin:". Interpret this as
910 a Cygwin signal. Otherwise just print the string as a warning. */
912 handle_output_debug_string (struct target_waitstatus *ourstatus)
917 if (!target_read_string
918 ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
922 if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
924 if (strncmp (s, "cYg", 3) != 0)
930 int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
931 gotasig = target_signal_from_host (sig);
932 ourstatus->value.sig = gotasig;
934 ourstatus->kind = TARGET_WAITKIND_STOPPED;
942 display_selector (HANDLE thread, DWORD sel)
945 if (GetThreadSelectorEntry (thread, sel, &info))
948 printf_filtered ("0x%03lx: ", sel);
949 if (!info.HighWord.Bits.Pres)
951 puts_filtered ("Segment not present\n");
954 base = (info.HighWord.Bits.BaseHi << 24) +
955 (info.HighWord.Bits.BaseMid << 16)
957 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
958 if (info.HighWord.Bits.Granularity)
959 limit = (limit << 12) | 0xfff;
960 printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
961 if (info.HighWord.Bits.Default_Big)
962 puts_filtered(" 32-bit ");
964 puts_filtered(" 16-bit ");
965 switch ((info.HighWord.Bits.Type & 0xf) >> 1)
968 puts_filtered ("Data (Read-Only, Exp-up");
971 puts_filtered ("Data (Read/Write, Exp-up");
974 puts_filtered ("Unused segment (");
977 puts_filtered ("Data (Read/Write, Exp-down");
980 puts_filtered ("Code (Exec-Only, N.Conf");
983 puts_filtered ("Code (Exec/Read, N.Conf");
986 puts_filtered ("Code (Exec-Only, Conf");
989 puts_filtered ("Code (Exec/Read, Conf");
992 printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
994 if ((info.HighWord.Bits.Type & 0x1) == 0)
995 puts_filtered(", N.Acc");
996 puts_filtered (")\n");
997 if ((info.HighWord.Bits.Type & 0x10) == 0)
998 puts_filtered("System selector ");
999 printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
1000 if (info.HighWord.Bits.Granularity)
1001 puts_filtered ("Page granular.\n");
1003 puts_filtered ("Byte granular.\n");
1008 printf_filtered ("Invalid selector 0x%lx.\n",sel);
1014 display_selectors (char * args, int from_tty)
1016 if (!current_thread)
1018 puts_filtered ("Impossible to display selectors now.\n");
1024 puts_filtered ("Selector $cs\n");
1025 display_selector (current_thread->h,
1026 current_thread->context.SegCs);
1027 puts_filtered ("Selector $ds\n");
1028 display_selector (current_thread->h,
1029 current_thread->context.SegDs);
1030 puts_filtered ("Selector $es\n");
1031 display_selector (current_thread->h,
1032 current_thread->context.SegEs);
1033 puts_filtered ("Selector $ss\n");
1034 display_selector (current_thread->h,
1035 current_thread->context.SegSs);
1036 puts_filtered ("Selector $fs\n");
1037 display_selector (current_thread->h,
1038 current_thread->context.SegFs);
1039 puts_filtered ("Selector $gs\n");
1040 display_selector (current_thread->h,
1041 current_thread->context.SegGs);
1046 sel = parse_and_eval_long (args);
1047 printf_filtered ("Selector \"%s\"\n",args);
1048 display_selector (current_thread->h, sel);
1052 static struct cmd_list_element *info_w32_cmdlist = NULL;
1055 info_w32_command (char *args, int from_tty)
1057 help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
1061 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1062 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1063 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1066 handle_exception (struct target_waitstatus *ourstatus)
1069 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1071 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1073 /* Record the context of the current thread */
1074 th = thread_rec (current_event.dwThreadId, -1);
1078 case EXCEPTION_ACCESS_VIOLATION:
1079 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1080 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1082 case STATUS_STACK_OVERFLOW:
1083 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1084 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1086 case STATUS_FLOAT_DENORMAL_OPERAND:
1087 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1088 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1090 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1091 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1092 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1094 case STATUS_FLOAT_INEXACT_RESULT:
1095 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1096 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1098 case STATUS_FLOAT_INVALID_OPERATION:
1099 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1100 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1102 case STATUS_FLOAT_OVERFLOW:
1103 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1104 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1106 case STATUS_FLOAT_STACK_CHECK:
1107 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1108 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1110 case STATUS_FLOAT_UNDERFLOW:
1111 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1112 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1114 case STATUS_FLOAT_DIVIDE_BY_ZERO:
1115 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1116 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1118 case STATUS_INTEGER_DIVIDE_BY_ZERO:
1119 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1120 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1122 case STATUS_INTEGER_OVERFLOW:
1123 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1124 ourstatus->value.sig = TARGET_SIGNAL_FPE;
1126 case EXCEPTION_BREAKPOINT:
1127 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1128 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1131 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1132 ourstatus->value.sig = TARGET_SIGNAL_INT;
1134 case DBG_CONTROL_BREAK:
1135 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1136 ourstatus->value.sig = TARGET_SIGNAL_INT;
1138 case EXCEPTION_SINGLE_STEP:
1139 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1140 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1142 case EXCEPTION_ILLEGAL_INSTRUCTION:
1143 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1144 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1146 case EXCEPTION_PRIV_INSTRUCTION:
1147 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1148 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1150 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1151 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1152 ourstatus->value.sig = TARGET_SIGNAL_ILL;
1155 if (current_event.u.Exception.dwFirstChance)
1157 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1158 current_event.u.Exception.ExceptionRecord.ExceptionCode,
1159 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1160 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1164 last_sig = ourstatus->value.sig;
1168 /* Resume all artificially suspended threads if we are continuing
1171 child_continue (DWORD continue_status, int id)
1177 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1178 current_event.dwProcessId, current_event.dwThreadId,
1179 continue_status == DBG_CONTINUE ?
1180 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1181 res = ContinueDebugEvent (current_event.dwProcessId,
1182 current_event.dwThreadId,
1184 continue_status = 0;
1186 for (th = &thread_head; (th = th->next) != NULL;)
1187 if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
1190 for (i = 0; i < th->suspend_count; i++)
1191 (void) ResumeThread (th->h);
1192 th->suspend_count = 0;
1193 if (debug_registers_changed)
1195 /* Only change the value of the debug registers */
1196 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
1197 th->context.Dr0 = dr[0];
1198 th->context.Dr1 = dr[1];
1199 th->context.Dr2 = dr[2];
1200 th->context.Dr3 = dr[3];
1201 /* th->context.Dr6 = dr[6];
1202 FIXME: should we set dr6 also ?? */
1203 th->context.Dr7 = dr[7];
1204 CHECK (SetThreadContext (th->h, &th->context));
1205 th->context.ContextFlags = 0;
1209 debug_registers_changed = 0;
1213 /* Called in pathological case where Windows fails to send a
1214 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1216 fake_create_process (void)
1218 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1219 current_event.dwProcessId);
1220 main_thread_id = current_event.dwThreadId;
1221 current_thread = child_add_thread (main_thread_id,
1222 current_event.u.CreateThread.hThread);
1223 return main_thread_id;
1226 /* Get the next event from the child. Return 1 if the event requires
1227 handling by WFI (or whatever).
1230 get_child_debug_event (int pid, struct target_waitstatus *ourstatus)
1233 DWORD continue_status, event_code;
1235 static thread_info dummy_thread_info;
1238 last_sig = TARGET_SIGNAL_0;
1240 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
1244 continue_status = DBG_CONTINUE;
1246 event_code = current_event.dwDebugEventCode;
1247 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1252 case CREATE_THREAD_DEBUG_EVENT:
1253 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1254 (unsigned) current_event.dwProcessId,
1255 (unsigned) current_event.dwThreadId,
1256 "CREATE_THREAD_DEBUG_EVENT"));
1257 if (saw_create != 1)
1259 if (!saw_create && attach_flag)
1261 /* Kludge around a Windows bug where first event is a create
1262 thread event. Caused when attached process does not have
1264 retval = ourstatus->value.related_pid = fake_create_process ();
1269 /* Record the existence of this thread */
1270 th = child_add_thread (current_event.dwThreadId,
1271 current_event.u.CreateThread.hThread);
1273 printf_unfiltered ("[New %s]\n",
1275 pid_to_ptid (current_event.dwThreadId)));
1276 retval = current_event.dwThreadId;
1279 case EXIT_THREAD_DEBUG_EVENT:
1280 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1281 (unsigned) current_event.dwProcessId,
1282 (unsigned) current_event.dwThreadId,
1283 "EXIT_THREAD_DEBUG_EVENT"));
1284 if (current_event.dwThreadId != main_thread_id)
1286 child_delete_thread (current_event.dwThreadId);
1287 th = &dummy_thread_info;
1291 case CREATE_PROCESS_DEBUG_EVENT:
1292 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1293 (unsigned) current_event.dwProcessId,
1294 (unsigned) current_event.dwThreadId,
1295 "CREATE_PROCESS_DEBUG_EVENT"));
1296 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1297 if (++saw_create != 1)
1299 CloseHandle (current_event.u.CreateProcessInfo.hProcess);
1303 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1305 child_delete_thread (main_thread_id);
1306 main_thread_id = current_event.dwThreadId;
1307 /* Add the main thread */
1308 th = child_add_thread (main_thread_id,
1309 current_event.u.CreateProcessInfo.hThread);
1310 retval = ourstatus->value.related_pid = current_event.dwThreadId;
1313 case EXIT_PROCESS_DEBUG_EVENT:
1314 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1315 (unsigned) current_event.dwProcessId,
1316 (unsigned) current_event.dwThreadId,
1317 "EXIT_PROCESS_DEBUG_EVENT"));
1318 if (saw_create != 1)
1320 ourstatus->kind = TARGET_WAITKIND_EXITED;
1321 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1322 CloseHandle (current_process_handle);
1323 retval = main_thread_id;
1326 case LOAD_DLL_DEBUG_EVENT:
1327 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1328 (unsigned) current_event.dwProcessId,
1329 (unsigned) current_event.dwThreadId,
1330 "LOAD_DLL_DEBUG_EVENT"));
1331 CloseHandle (current_event.u.LoadDll.hFile);
1332 if (saw_create != 1)
1334 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1335 registers_changed (); /* mark all regs invalid */
1336 ourstatus->kind = TARGET_WAITKIND_LOADED;
1337 ourstatus->value.integer = 0;
1338 retval = main_thread_id;
1339 re_enable_breakpoints_in_shlibs ();
1342 case UNLOAD_DLL_DEBUG_EVENT:
1343 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1344 (unsigned) current_event.dwProcessId,
1345 (unsigned) current_event.dwThreadId,
1346 "UNLOAD_DLL_DEBUG_EVENT"));
1347 if (saw_create != 1)
1349 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1350 registers_changed (); /* mark all regs invalid */
1351 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1352 does not exist yet. */
1355 case EXCEPTION_DEBUG_EVENT:
1356 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1357 (unsigned) current_event.dwProcessId,
1358 (unsigned) current_event.dwThreadId,
1359 "EXCEPTION_DEBUG_EVENT"));
1360 if (saw_create != 1)
1362 if (handle_exception (ourstatus))
1363 retval = current_event.dwThreadId;
1366 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1367 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1368 (unsigned) current_event.dwProcessId,
1369 (unsigned) current_event.dwThreadId,
1370 "OUTPUT_DEBUG_STRING_EVENT"));
1371 if (saw_create != 1)
1373 if (handle_output_debug_string (ourstatus))
1374 retval = main_thread_id;
1378 if (saw_create != 1)
1380 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1381 (DWORD) current_event.dwProcessId,
1382 (DWORD) current_event.dwThreadId);
1383 printf_unfiltered (" unknown event code %ld\n",
1384 current_event.dwDebugEventCode);
1388 if (!retval || saw_create != 1)
1389 CHECK (child_continue (continue_status, -1));
1392 inferior_ptid = pid_to_ptid (retval);
1393 current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1400 /* Wait for interesting events to occur in the target process. */
1402 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1404 int pid = PIDGET (ptid);
1406 /* We loop when we get a non-standard exception rather than return
1407 with a SPURIOUS because resume can try and step or modify things,
1408 which needs a current_thread->h. But some of these exceptions mark
1409 the birth or death of threads, which mean that the current thread
1410 isn't necessarily what you think it is. */
1414 int retval = get_child_debug_event (pid, ourstatus);
1416 return pid_to_ptid (retval);
1421 if (deprecated_ui_loop_hook != NULL)
1422 detach = deprecated_ui_loop_hook (0);
1425 child_kill_inferior ();
1431 do_initial_child_stuff (DWORD pid)
1433 extern int stop_after_trap;
1436 last_sig = TARGET_SIGNAL_0;
1438 exception_count = 0;
1439 debug_registers_changed = 0;
1440 debug_registers_used = 0;
1441 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1443 current_event.dwProcessId = pid;
1444 memset (¤t_event, 0, sizeof (current_event));
1445 push_target (&child_ops);
1446 child_init_thread_list ();
1447 disable_breakpoints_in_shlibs (1);
1448 child_clear_solibs ();
1449 clear_proceed_status ();
1450 init_wait_for_inferior ();
1452 target_terminal_init ();
1453 target_terminal_inferior ();
1457 stop_after_trap = 1;
1458 wait_for_inferior ();
1459 if (stop_signal != TARGET_SIGNAL_TRAP)
1460 resume (0, stop_signal);
1464 stop_after_trap = 0;
1468 /* Since Windows XP, detaching from a process is supported by Windows.
1469 The following code tries loading the appropriate functions dynamically.
1470 If loading these functions succeeds use them to actually detach from
1471 the inferior process, otherwise behave as usual, pretending that
1472 detach has worked. */
1473 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1474 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1477 has_detach_ability (void)
1479 static HMODULE kernel32 = NULL;
1482 kernel32 = LoadLibrary ("kernel32.dll");
1485 if (!DebugSetProcessKillOnExit)
1486 DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1487 "DebugSetProcessKillOnExit");
1488 if (!DebugActiveProcessStop)
1489 DebugActiveProcessStop = GetProcAddress (kernel32,
1490 "DebugActiveProcessStop");
1491 if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1497 /* Try to set or remove a user privilege to the current process. Return -1
1498 if that fails, the previous setting of that privilege otherwise.
1500 This code is copied from the Cygwin source code and rearranged to allow
1501 dynamically loading of the needed symbols from advapi32 which is only
1502 available on NT/2K/XP. */
1504 set_process_privilege (const char *privilege, BOOL enable)
1506 static HMODULE advapi32 = NULL;
1507 static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1508 static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1509 static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1510 DWORD, PTOKEN_PRIVILEGES, PDWORD);
1512 HANDLE token_hdl = NULL;
1514 TOKEN_PRIVILEGES new_priv, orig_priv;
1518 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1523 if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1525 if (!OpenProcessToken)
1526 OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1527 if (!LookupPrivilegeValue)
1528 LookupPrivilegeValue = GetProcAddress (advapi32,
1529 "LookupPrivilegeValueA");
1530 if (!AdjustTokenPrivileges)
1531 AdjustTokenPrivileges = GetProcAddress (advapi32,
1532 "AdjustTokenPrivileges");
1533 if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1540 if (!OpenProcessToken (GetCurrentProcess (),
1541 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1545 if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1548 new_priv.PrivilegeCount = 1;
1549 new_priv.Privileges[0].Luid = restore_priv;
1550 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1552 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1553 sizeof orig_priv, &orig_priv, &size))
1556 /* Disabled, otherwise every `attach' in an unprivileged user session
1557 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1559 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1560 be enabled. GetLastError () returns an correct error code, though. */
1561 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1565 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1569 CloseHandle (token_hdl);
1574 /* Attach to process PID, then initialize for debugging it. */
1576 child_attach (char *args, int from_tty)
1582 error_no_arg ("process-id to attach");
1584 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1586 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1587 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1590 pid = strtoul (args, 0, 0); /* Windows pid */
1592 ok = DebugActiveProcess (pid);
1597 /* Try fall back to Cygwin pid */
1598 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1601 ok = DebugActiveProcess (pid);
1604 error ("Can't attach to process.");
1607 if (has_detach_ability ())
1608 DebugSetProcessKillOnExit (FALSE);
1614 char *exec_file = (char *) get_exec_file (0);
1617 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1618 target_pid_to_str (pid_to_ptid (pid)));
1620 printf_unfiltered ("Attaching to %s\n",
1621 target_pid_to_str (pid_to_ptid (pid)));
1623 gdb_flush (gdb_stdout);
1626 do_initial_child_stuff (pid);
1627 target_terminal_ours ();
1631 child_detach (char *args, int from_tty)
1635 if (has_detach_ability ())
1637 delete_command (NULL, 0);
1638 child_continue (DBG_CONTINUE, -1);
1639 if (!DebugActiveProcessStop (current_event.dwProcessId))
1641 error ("Can't detach process %lu (error %lu)",
1642 current_event.dwProcessId, GetLastError ());
1645 DebugSetProcessKillOnExit (FALSE);
1647 if (detached && from_tty)
1649 char *exec_file = get_exec_file (0);
1652 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1653 current_event.dwProcessId);
1654 gdb_flush (gdb_stdout);
1656 inferior_ptid = null_ptid;
1657 unpush_target (&child_ops);
1661 child_pid_to_exec_file (int pid)
1663 /* Try to find the process path using the Cygwin internal process list
1664 pid isn't a valid pid, unfortunately. Use current_event.dwProcessId
1666 /* TODO: Also find native Windows processes using CW_GETPINFO_FULL. */
1668 static char path[MAX_PATH + 1];
1669 char *path_ptr = NULL;
1671 struct external_pinfo *pinfo;
1673 cygwin_internal (CW_LOCK_PINFO, 1000);
1675 (pinfo = (struct external_pinfo *)
1676 cygwin_internal (CW_GETPINFO, cpid | CW_NEXTPID));
1679 if (pinfo->dwProcessId == current_event.dwProcessId) /* Got it */
1681 cygwin_conv_to_full_posix_path (pinfo->progname, path);
1686 cygwin_internal (CW_UNLOCK_PINFO);
1690 /* Print status information about what we're accessing. */
1693 child_files_info (struct target_ops *ignore)
1695 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1696 attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1700 child_open (char *arg, int from_tty)
1702 error ("Use the \"run\" command to start a Unix child process.");
1705 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1706 EXEC_FILE is the file to run.
1707 ALLARGS is a string containing the arguments to the program.
1708 ENV is the environment vector to pass. Errors reported with error(). */
1711 child_create_inferior (char *exec_file, char *allargs, char **env,
1719 PROCESS_INFORMATION pi;
1723 char real_path[MAXPATHLEN];
1725 char shell[MAX_PATH + 1]; /* Path to shell */
1728 int ostdin, ostdout, ostderr;
1731 error ("No executable specified, use `target exec'.\n");
1733 memset (&si, 0, sizeof (si));
1734 si.cb = sizeof (si);
1738 flags = DEBUG_ONLY_THIS_PROCESS;
1739 cygwin_conv_to_win32_path (exec_file, real_path);
1745 sh = getenv ("SHELL");
1748 cygwin_conv_to_win32_path (sh, shell);
1749 newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)
1750 + strlen (allargs) + 2);
1751 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1752 allargs = newallargs;
1754 flags = DEBUG_PROCESS;
1758 flags |= CREATE_NEW_PROCESS_GROUP;
1761 flags |= CREATE_NEW_CONSOLE;
1765 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1766 strcpy (args, toexec);
1768 strcat (args, allargs);
1770 /* Prepare the environment vars for CreateProcess. */
1772 /* This code used to assume all env vars were file names and would
1773 translate them all to win32 style. That obviously doesn't work in the
1774 general case. The current rule is that we only translate PATH.
1775 We need to handle PATH because we're about to call CreateProcess and
1776 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1777 in both posix and win32 environments. cygwin.dll will change it back
1778 to posix style if necessary. */
1780 static const char *conv_path_names[] =
1786 /* CreateProcess takes the environment list as a null terminated set of
1787 strings (i.e. two nulls terminate the list). */
1789 /* Get total size for env strings. */
1790 for (envlen = 0, i = 0; env[i] && *env[i]; i++)
1794 for (j = 0; conv_path_names[j]; j++)
1796 len = strlen (conv_path_names[j]);
1797 if (strncmp (conv_path_names[j], env[i], len) == 0)
1799 if (cygwin_posix_path_list_p (env[i] + len))
1801 + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
1803 envlen += strlen (env[i]) + 1;
1807 if (conv_path_names[j] == NULL)
1808 envlen += strlen (env[i]) + 1;
1811 winenv = alloca (envlen + 1);
1813 /* Copy env strings into new buffer. */
1814 for (temp = winenv, i = 0; env[i] && *env[i]; i++)
1818 for (j = 0; conv_path_names[j]; j++)
1820 len = strlen (conv_path_names[j]);
1821 if (strncmp (conv_path_names[j], env[i], len) == 0)
1823 if (cygwin_posix_path_list_p (env[i] + len))
1825 memcpy (temp, env[i], len);
1826 cygwin_posix_to_win32_path_list (env[i] + len, temp + len);
1829 strcpy (temp, env[i]);
1833 if (conv_path_names[j] == NULL)
1834 strcpy (temp, env[i]);
1836 temp += strlen (temp) + 1;
1839 /* Final nil string to terminate new env. */
1843 if (!inferior_io_terminal)
1844 tty = ostdin = ostdout = ostderr = -1;
1847 tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1850 print_sys_errmsg (inferior_io_terminal, errno);
1851 ostdin = ostdout = ostderr = -1;
1864 ret = CreateProcess (0,
1865 args, /* command line */
1866 NULL, /* Security */
1868 TRUE, /* inherit handles */
1869 flags, /* start flags */
1871 NULL, /* current directory */
1886 error ("Error creating process %s, (error %d)\n", exec_file, (unsigned) GetLastError ());
1888 CloseHandle (pi.hThread);
1889 CloseHandle (pi.hProcess);
1891 if (useshell && shell[0] != '\0')
1896 do_initial_child_stuff (pi.dwProcessId);
1898 /* child_continue (DBG_CONTINUE, -1); */
1899 proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
1903 child_mourn_inferior (void)
1905 (void) child_continue (DBG_CONTINUE, -1);
1906 i386_cleanup_dregs();
1907 unpush_target (&child_ops);
1908 generic_mourn_inferior ();
1911 /* Send a SIGINT to the process group. This acts just like the user typed a
1912 ^C on the controlling terminal. */
1917 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1918 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1919 registers_changed (); /* refresh register state */
1923 child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
1924 int write, struct mem_attrib *mem,
1925 struct target_ops *target)
1930 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1931 len, (DWORD) memaddr));
1932 if (!WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,
1935 FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);
1939 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1940 len, (DWORD) memaddr));
1941 if (!ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our,
1949 child_kill_inferior (void)
1951 CHECK (TerminateProcess (current_process_handle, 0));
1955 if (!child_continue (DBG_CONTINUE, -1))
1957 if (!WaitForDebugEvent (¤t_event, INFINITE))
1959 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1963 CHECK (CloseHandle (current_process_handle));
1965 /* this may fail in an attached process so don't check. */
1966 if (current_thread && current_thread->h)
1967 (void) CloseHandle (current_thread->h);
1968 target_mourn_inferior (); /* or just child_mourn_inferior? */
1972 child_resume (ptid_t ptid, int step, enum target_signal sig)
1975 DWORD continue_status = DBG_CONTINUE;
1977 int pid = PIDGET (ptid);
1979 if (sig != TARGET_SIGNAL_0)
1981 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1983 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1985 else if (sig == last_sig)
1986 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1989 /* This code does not seem to work, because
1990 the kernel does probably not consider changes in the ExceptionRecord
1991 structure when passing the exception to the inferior.
1992 Note that this seems possible in the exception handler itself. */
1995 for (i = 0; xlate[i].them != -1; i++)
1996 if (xlate[i].us == sig)
1998 current_event.u.Exception.ExceptionRecord.ExceptionCode =
2000 continue_status = DBG_EXCEPTION_NOT_HANDLED;
2003 if (continue_status == DBG_CONTINUE)
2005 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
2009 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
2013 last_sig = TARGET_SIGNAL_0;
2015 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
2018 /* Get context for currently selected thread */
2019 th = thread_rec (current_event.dwThreadId, FALSE);
2024 /* Single step by setting t bit */
2025 child_fetch_inferior_registers (PS_REGNUM);
2026 th->context.EFlags |= FLAG_TRACE_BIT;
2029 if (th->context.ContextFlags)
2031 if (debug_registers_changed)
2033 th->context.Dr0 = dr[0];
2034 th->context.Dr1 = dr[1];
2035 th->context.Dr2 = dr[2];
2036 th->context.Dr3 = dr[3];
2037 /* th->context.Dr6 = dr[6];
2038 FIXME: should we set dr6 also ?? */
2039 th->context.Dr7 = dr[7];
2041 CHECK (SetThreadContext (th->h, &th->context));
2042 th->context.ContextFlags = 0;
2046 /* Allow continuing with the same signal that interrupted us.
2047 Otherwise complain. */
2049 child_continue (continue_status, pid);
2053 child_prepare_to_store (void)
2055 /* Do nothing, since we can store individual regs */
2059 child_can_run (void)
2067 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
2068 PIDGET (inferior_ptid)));
2071 struct target_ops child_ops;
2074 init_child_ops (void)
2076 child_ops.to_shortname = "child";
2077 child_ops.to_longname = "Win32 child process";
2078 child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2079 child_ops.to_open = child_open;
2080 child_ops.to_close = child_close;
2081 child_ops.to_attach = child_attach;
2082 child_ops.to_detach = child_detach;
2083 child_ops.to_resume = child_resume;
2084 child_ops.to_wait = child_wait;
2085 child_ops.to_fetch_registers = child_fetch_inferior_registers;
2086 child_ops.to_store_registers = child_store_inferior_registers;
2087 child_ops.to_prepare_to_store = child_prepare_to_store;
2088 child_ops.to_xfer_memory = child_xfer_memory;
2089 child_ops.to_files_info = child_files_info;
2090 child_ops.to_insert_breakpoint = memory_insert_breakpoint;
2091 child_ops.to_remove_breakpoint = memory_remove_breakpoint;
2092 child_ops.to_terminal_init = terminal_init_inferior;
2093 child_ops.to_terminal_inferior = terminal_inferior;
2094 child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2095 child_ops.to_terminal_ours = terminal_ours;
2096 child_ops.to_terminal_save_ours = terminal_save_ours;
2097 child_ops.to_terminal_info = child_terminal_info;
2098 child_ops.to_kill = child_kill_inferior;
2099 child_ops.to_create_inferior = child_create_inferior;
2100 child_ops.to_mourn_inferior = child_mourn_inferior;
2101 child_ops.to_can_run = child_can_run;
2102 child_ops.to_thread_alive = win32_child_thread_alive;
2103 child_ops.to_pid_to_str = cygwin_pid_to_str;
2104 child_ops.to_stop = child_stop;
2105 child_ops.to_stratum = process_stratum;
2106 child_ops.to_has_all_memory = 1;
2107 child_ops.to_has_memory = 1;
2108 child_ops.to_has_stack = 1;
2109 child_ops.to_has_registers = 1;
2110 child_ops.to_has_execution = 1;
2111 child_ops.to_magic = OPS_MAGIC;
2112 child_ops.to_pid_to_exec_file = child_pid_to_exec_file;
2116 _initialize_win32_nat (void)
2118 struct cmd_list_element *c;
2122 c = add_com ("dll-symbols", class_files, dll_symbol_command,
2123 "Load dll library symbols from FILE.");
2124 set_cmd_completer (c, filename_completer);
2126 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2128 add_show_from_set (add_set_cmd ("shell", class_support, var_boolean,
2130 "Set use of shell to start subprocess.",
2134 add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,
2135 (char *) &new_console,
2136 "Set creation of new console when creating child process.",
2140 add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,
2141 (char *) &new_group,
2142 "Set creation of new group when creating child process.",
2146 add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,
2147 (char *) &debug_exec,
2148 "Set whether to display execution in child process.",
2152 add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,
2153 (char *) &debug_events,
2154 "Set whether to display kernel events in child process.",
2158 add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,
2159 (char *) &debug_memory,
2160 "Set whether to display memory accesses in child process.",
2164 add_show_from_set (add_set_cmd ("debugexceptions", class_support, var_boolean,
2165 (char *) &debug_exceptions,
2166 "Set whether to display kernel exceptions in child process.",
2170 add_info ("dll", info_dll_command, "Status of loaded DLLs.");
2171 add_info_alias ("sharedlibrary", "dll", 1);
2173 add_prefix_cmd ("w32", class_info, info_w32_command,
2174 "Print information specific to Win32 debugging.",
2175 &info_w32_cmdlist, "info w32 ", 0, &infolist);
2177 add_cmd ("selector", class_info, display_selectors,
2178 "Display selectors infos.",
2181 add_target (&child_ops);
2184 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2186 /* Pass the address ADDR to the inferior in the I'th debug register.
2187 Here we just store the address in dr array, the registers will be
2188 actually set up when child_continue is called. */
2190 cygwin_set_dr (int i, CORE_ADDR addr)
2193 internal_error (__FILE__, __LINE__,
2194 "Invalid register %d in cygwin_set_dr.\n", i);
2195 dr[i] = (unsigned) addr;
2196 debug_registers_changed = 1;
2197 debug_registers_used = 1;
2200 /* Pass the value VAL to the inferior in the DR7 debug control
2201 register. Here we just store the address in D_REGS, the watchpoint
2202 will be actually set up in child_wait. */
2204 cygwin_set_dr7 (unsigned val)
2207 debug_registers_changed = 1;
2208 debug_registers_used = 1;
2211 /* Get the value of the DR6 debug status register from the inferior.
2212 Here we just return the value stored in dr[6]
2213 by the last call to thread_rec for current_event.dwThreadId id. */
2215 cygwin_get_dr6 (void)
2220 /* Determine if the thread referenced by "pid" is alive
2221 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2222 it means that the pid has died. Otherwise it is assumed to be alive. */
2224 win32_child_thread_alive (ptid_t ptid)
2226 int pid = PIDGET (ptid);
2228 return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2232 /* Convert pid to printable format. */
2234 cygwin_pid_to_str (ptid_t ptid)
2236 static char buf[80];
2237 int pid = PIDGET (ptid);
2239 if ((DWORD) pid == current_event.dwProcessId)
2240 sprintf (buf, "process %d", pid);
2242 sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
2247 core_dll_symbols_add (char *dll_name, DWORD base_addr)
2249 struct objfile *objfile;
2250 char *objfile_basename;
2251 const char *dll_basename;
2253 if (!(dll_basename = strrchr (dll_name, '/')))
2254 dll_basename = dll_name;
2258 ALL_OBJFILES (objfile)
2260 objfile_basename = strrchr (objfile->name, '/');
2262 if (objfile_basename &&
2263 strcmp (dll_basename, objfile_basename + 1) == 0)
2265 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2266 base_addr, dll_name);
2271 register_loaded_dll (dll_name, base_addr + 0x1000);
2272 solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);
2280 struct target_ops *target;
2282 } map_code_section_args;
2285 map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)
2289 struct section_table *new_target_sect_ptr;
2291 map_code_section_args *args = (map_code_section_args *) obj;
2292 struct target_ops *target = args->target;
2293 if (sect->flags & SEC_CODE)
2295 update_coreops = core_ops.to_sections == target->to_sections;
2297 if (target->to_sections)
2299 old = target->to_sections_end - target->to_sections;
2300 target->to_sections = (struct section_table *)
2301 xrealloc ((char *) target->to_sections,
2302 (sizeof (struct section_table)) * (1 + old));
2307 target->to_sections = (struct section_table *)
2308 xmalloc ((sizeof (struct section_table)));
2310 target->to_sections_end = target->to_sections + (1 + old);
2312 /* Update the to_sections field in the core_ops structure
2316 core_ops.to_sections = target->to_sections;
2317 core_ops.to_sections_end = target->to_sections_end;
2319 new_target_sect_ptr = target->to_sections + old;
2320 new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
2321 new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
2322 bfd_section_size (abfd, sect);;
2323 new_target_sect_ptr->the_bfd_section = sect;
2324 new_target_sect_ptr->bfd = abfd;
2329 dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
2332 map_code_section_args map_args;
2333 asection *lowest_sect;
2335 if (dll_name == NULL || target == NULL)
2337 name = xstrdup (dll_name);
2338 dll_bfd = bfd_openr (name, "pei-i386");
2339 if (dll_bfd == NULL)
2342 if (bfd_check_format (dll_bfd, bfd_object))
2344 lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
2345 if (lowest_sect == NULL)
2347 map_args.target = target;
2348 map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
2350 bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
2357 core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)
2359 struct target_ops *target = (struct target_ops *) obj;
2364 char *dll_name = NULL;
2366 struct win32_pstatus *pstatus;
2369 if (strncmp (sect->name, ".module", 7))
2372 buf = (char *) xmalloc (bfd_get_section_size (sect) + 1);
2375 printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2378 if (!bfd_get_section_contents (abfd, sect, buf, 0, bfd_get_section_size (sect)))
2381 pstatus = (struct win32_pstatus *) buf;
2383 memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
2384 dll_name_size = pstatus->data.module_info.module_name_size;
2385 if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > bfd_get_section_size (sect))
2388 dll_name = (char *) xmalloc (dll_name_size + 1);
2391 printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2394 strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);
2396 while ((p = strchr (dll_name, '\\')))
2399 if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))
2400 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);
2402 if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))
2403 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
2414 child_solib_add (char *filename, int from_tty, struct target_ops *target,
2421 child_clear_solibs ();
2422 bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);
2426 if (solib_end && solib_end->name)
2427 solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,
2428 solib_end->load_addr);
2433 fetch_elf_core_registers (char *core_reg_sect,
2434 unsigned core_reg_size,
2439 if (core_reg_size < sizeof (CONTEXT))
2441 error ("Core file register section too small (%u bytes).", core_reg_size);
2444 for (r = 0; r < NUM_REGS; r++)
2445 regcache_raw_supply (current_regcache, r, core_reg_sect + mappings[r]);
2448 static struct core_fns win32_elf_core_fns =
2450 bfd_target_elf_flavour,
2451 default_check_format,
2452 default_core_sniffer,
2453 fetch_elf_core_registers,
2458 _initialize_core_win32 (void)
2460 deprecated_add_core_fns (&win32_elf_core_fns);
2464 _initialize_check_for_gdb_ini (void)
2467 if (inhibit_gdbinit)
2470 homedir = getenv ("HOME");
2474 char *oldini = (char *) alloca (strlen (homedir) +
2475 sizeof ("/gdb.ini"));
2476 strcpy (oldini, homedir);
2477 p = strchr (oldini, '\0');
2478 if (p > oldini && p[-1] != '/')
2480 strcpy (p, "gdb.ini");
2481 if (access (oldini, 0) == 0)
2483 int len = strlen (oldini);
2484 char *newini = alloca (len + 1);
2485 sprintf (newini, "%.*s.gdbinit",
2486 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2487 warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);