1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free
4 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 "tm.h" /* required for SSE registers */
31 #include "frame.h" /* required by inferior.h */
36 #include "completer.h"
39 #include "i386-tdep.h"
41 #include <sys/types.h>
46 #include <sys/cygwin.h>
51 #include "gdb_string.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
57 /* The ui's event loop. */
58 extern int (*ui_loop_hook) (int signo);
60 /* If we're not using the old Cygwin header file set, define the
61 following which never should have been in the generic Win32 API
62 headers in the first place since they were our own invention... */
63 #ifndef _GNU_H_WINDOWS_H
66 FLAG_TRACE_BIT = 0x100,
67 CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
70 #include <sys/procfs.h>
74 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
75 | CONTEXT_EXTENDED_REGISTERS
77 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS
80 static unsigned dr[8];
81 static int debug_registers_changed = 0;
82 static int debug_registers_used = 0;
84 /* The string sent by cygwin when it processes a signal.
85 FIXME: This should be in a cygwin include file. */
86 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
88 #define CHECK(x) check (x, __FILE__,__LINE__)
89 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
90 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
91 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
92 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
94 /* Forward declaration */
95 extern struct target_ops child_ops;
97 static void child_stop (void);
98 static int win32_child_thread_alive (ptid_t);
99 void child_kill_inferior (void);
101 static enum target_signal last_sig = TARGET_SIGNAL_0;
102 /* Set if a signal was received from the debugged process */
104 /* Thread information structure used to track information that is
105 not available in gdb's thread structure. */
106 typedef struct thread_info_struct
108 struct thread_info_struct *next;
118 static thread_info thread_head;
120 /* The process and thread handles for the above context. */
122 static DEBUG_EVENT current_event; /* The current debug event from
124 static HANDLE current_process_handle; /* Currently executing process */
125 static thread_info *current_thread; /* Info on currently selected thread */
126 static DWORD main_thread_id; /* Thread ID of the main thread */
128 /* Counts of things. */
129 static int exception_count = 0;
130 static int event_count = 0;
131 static int saw_create;
134 static int new_console = 0;
135 static int new_group = 1;
136 static int debug_exec = 0; /* show execution */
137 static int debug_events = 0; /* show events from kernel */
138 static int debug_memory = 0; /* show target memory accesses */
139 static int debug_exceptions = 0; /* show target exceptions */
140 static int useshell = 0; /* use shell for subprocesses */
143 static char shell[MAX_PATH + 1];
145 /* This vector maps GDB's idea of a register's number into an address
146 in the win32 exception context vector.
148 It also contains the bit mask needed to load the register in question.
150 One day we could read a reg, we could inspect the context we
151 already have loaded, if it doesn't have the bit set that we need,
152 we read that set of registers in using GetThreadContext. If the
153 context already contains what we need, we just unpack it. Then to
154 write a register, first we have to ensure that the context contains
155 the other regs of the group, and then we copy the info in and set
158 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
159 static const int mappings[] =
161 context_offset (Eax),
162 context_offset (Ecx),
163 context_offset (Edx),
164 context_offset (Ebx),
165 context_offset (Esp),
166 context_offset (Ebp),
167 context_offset (Esi),
168 context_offset (Edi),
169 context_offset (Eip),
170 context_offset (EFlags),
171 context_offset (SegCs),
172 context_offset (SegSs),
173 context_offset (SegDs),
174 context_offset (SegEs),
175 context_offset (SegFs),
176 context_offset (SegGs),
177 context_offset (FloatSave.RegisterArea[0 * 10]),
178 context_offset (FloatSave.RegisterArea[1 * 10]),
179 context_offset (FloatSave.RegisterArea[2 * 10]),
180 context_offset (FloatSave.RegisterArea[3 * 10]),
181 context_offset (FloatSave.RegisterArea[4 * 10]),
182 context_offset (FloatSave.RegisterArea[5 * 10]),
183 context_offset (FloatSave.RegisterArea[6 * 10]),
184 context_offset (FloatSave.RegisterArea[7 * 10]),
185 context_offset (FloatSave.ControlWord),
186 context_offset (FloatSave.StatusWord),
187 context_offset (FloatSave.TagWord),
188 context_offset (FloatSave.ErrorSelector),
189 context_offset (FloatSave.ErrorOffset),
190 context_offset (FloatSave.DataSelector),
191 context_offset (FloatSave.DataOffset),
192 context_offset (FloatSave.ErrorSelector)
195 context_offset (ExtendedRegisters[10*16]),
196 context_offset (ExtendedRegisters[11*16]),
197 context_offset (ExtendedRegisters[12*16]),
198 context_offset (ExtendedRegisters[13*16]),
199 context_offset (ExtendedRegisters[14*16]),
200 context_offset (ExtendedRegisters[15*16]),
201 context_offset (ExtendedRegisters[16*16]),
202 context_offset (ExtendedRegisters[17*16]),
204 context_offset (ExtendedRegisters[24])
208 #undef context_offset
210 /* This vector maps the target's idea of an exception (extracted
211 from the DEBUG_EVENT structure) to GDB's idea. */
213 struct xlate_exception
216 enum target_signal us;
219 static const struct xlate_exception
222 {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
223 {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
224 {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
225 {DBG_CONTROL_C, TARGET_SIGNAL_INT},
226 {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
227 {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
231 check (BOOL ok, const char *file, int line)
234 printf_filtered ("error return %s:%d was %lu\n", file, line,
239 /* Find a thread record given a thread id.
240 If get_context then also retrieve the context for this
243 thread_rec (DWORD id, int get_context)
247 for (th = &thread_head; (th = th->next) != NULL;)
250 if (!th->suspend_count && get_context)
252 if (get_context > 0 && id != current_event.dwThreadId)
253 th->suspend_count = SuspendThread (th->h) + 1;
254 else if (get_context < 0)
255 th->suspend_count = -1;
257 th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
258 GetThreadContext (th->h, &th->context);
259 if (id == current_event.dwThreadId)
261 /* Copy dr values from that thread. */
262 dr[0] = th->context.Dr0;
263 dr[1] = th->context.Dr1;
264 dr[2] = th->context.Dr2;
265 dr[3] = th->context.Dr3;
266 dr[6] = th->context.Dr6;
267 dr[7] = th->context.Dr7;
276 /* Add a thread to the thread list */
278 child_add_thread (DWORD id, HANDLE h)
282 if ((th = thread_rec (id, FALSE)))
285 th = (thread_info *) xmalloc (sizeof (*th));
286 memset (th, 0, sizeof (*th));
289 th->next = thread_head.next;
290 thread_head.next = th;
291 add_thread (pid_to_ptid (id));
292 /* Set the debug registers for the new thread in they are used. */
293 if (debug_registers_used)
295 /* Only change the value of the debug registers. */
296 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
297 CHECK (GetThreadContext (th->h, &th->context));
298 th->context.Dr0 = dr[0];
299 th->context.Dr1 = dr[1];
300 th->context.Dr2 = dr[2];
301 th->context.Dr3 = dr[3];
302 /* th->context.Dr6 = dr[6];
303 FIXME: should we set dr6 also ?? */
304 th->context.Dr7 = dr[7];
305 CHECK (SetThreadContext (th->h, &th->context));
306 th->context.ContextFlags = 0;
311 /* Clear out any old thread list and reintialize it to a
314 child_init_thread_list (void)
316 thread_info *th = &thread_head;
318 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
320 while (th->next != NULL)
322 thread_info *here = th->next;
323 th->next = here->next;
324 (void) CloseHandle (here->h);
329 /* Delete a thread from the list of threads */
331 child_delete_thread (DWORD id)
336 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
337 delete_thread (pid_to_ptid (id));
339 for (th = &thread_head;
340 th->next != NULL && th->next->id != id;
344 if (th->next != NULL)
346 thread_info *here = th->next;
347 th->next = here->next;
348 CloseHandle (here->h);
354 do_child_fetch_inferior_registers (int r)
356 char *context_offset = ((char *) ¤t_thread->context) + mappings[r];
360 l = *((long *) context_offset) & 0xffff;
361 supply_register (r, (char *) &l);
363 else if (r == FOP_REGNUM)
365 l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
366 supply_register (r, (char *) &l);
369 supply_register (r, context_offset);
372 for (r = 0; r < NUM_REGS; r++)
373 do_child_fetch_inferior_registers (r);
378 child_fetch_inferior_registers (int r)
380 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
381 do_child_fetch_inferior_registers (r);
385 do_child_store_inferior_registers (int r)
388 read_register_gen (r, ((char *) ¤t_thread->context) + mappings[r]);
391 for (r = 0; r < NUM_REGS; r++)
392 do_child_store_inferior_registers (r);
396 /* Store a new register value into the current thread context */
398 child_store_inferior_registers (int r)
400 current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
401 do_child_store_inferior_registers (r);
404 static int psapi_loaded = 0;
405 static HMODULE psapi_module_handle = NULL;
406 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD, LPDWORD) = NULL;
407 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;
408 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;
411 psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)
417 HMODULE *DllHandle = dh_buf;
422 psapi_EnumProcessModules == NULL ||
423 psapi_GetModuleInformation == NULL ||
424 psapi_GetModuleFileNameExA == NULL)
429 psapi_module_handle = LoadLibrary ("psapi.dll");
430 if (!psapi_module_handle)
432 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
435 psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");
436 psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");
437 psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,
438 "GetModuleFileNameExA");
439 if (psapi_EnumProcessModules == NULL ||
440 psapi_GetModuleInformation == NULL ||
441 psapi_GetModuleFileNameExA == NULL)
446 ok = (*psapi_EnumProcessModules) (current_process_handle,
451 if (!ok || !cbNeeded)
454 DllHandle = (HMODULE *) alloca (cbNeeded);
458 ok = (*psapi_EnumProcessModules) (current_process_handle,
465 for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
467 if (!(*psapi_GetModuleInformation) (current_process_handle,
471 error ("Can't get module info");
473 len = (*psapi_GetModuleFileNameExA) (current_process_handle,
478 error ("Error getting dll name: %u\n", GetLastError ());
480 if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)
485 dll_name_ret[0] = '\0';
489 /* Encapsulate the information required in a call to
490 symbol_file_add_args */
491 struct safe_symbol_file_add_args
495 struct section_addr_info *addrs;
498 struct ui_file *err, *out;
502 /* Maintain a linked list of "so" information. */
505 struct so_stuff *next;
508 struct objfile *objfile;
510 } solib_start, *solib_end;
512 /* Call symbol_file_add with stderr redirected. We don't care if there
515 safe_symbol_file_add_stub (void *argv)
517 #define p ((struct safe_symbol_file_add_args *)argv)
518 struct so_stuff *so = &solib_start;
520 while ((so = so->next))
521 if (so->loaded && strcasecmp (so->name, p->name) == 0)
523 p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
528 /* Restore gdb's stderr after calling symbol_file_add */
530 safe_symbol_file_add_cleanup (void *p)
532 #define sp ((struct safe_symbol_file_add_args *)p)
533 gdb_flush (gdb_stderr);
534 gdb_flush (gdb_stdout);
535 ui_file_delete (gdb_stderr);
536 ui_file_delete (gdb_stdout);
537 gdb_stderr = sp->err;
538 gdb_stdout = sp->out;
542 /* symbol_file_add wrapper that prevents errors from being displayed. */
543 static struct objfile *
544 safe_symbol_file_add (char *name, int from_tty,
545 struct section_addr_info *addrs,
546 int mainline, int flags)
548 struct safe_symbol_file_add_args p;
549 struct cleanup *cleanup;
551 cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
555 gdb_flush (gdb_stderr);
556 gdb_flush (gdb_stdout);
557 gdb_stderr = ui_file_new ();
558 gdb_stdout = ui_file_new ();
560 p.from_tty = from_tty;
562 p.mainline = mainline;
564 catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
566 do_cleanups (cleanup);
570 /* Remember the maximum DLL length for printing in info dll command. */
571 int max_dll_name_len;
574 register_loaded_dll (const char *name, DWORD load_addr)
577 char ppath[MAX_PATH + 1];
578 char buf[MAX_PATH + 1];
579 char cwd[MAX_PATH + 1];
581 WIN32_FIND_DATA w32_fd;
582 HANDLE h = FindFirstFile(name, &w32_fd);
587 if (GetCurrentDirectory (MAX_PATH + 1, cwd))
589 p = strrchr (buf, '\\');
592 SetCurrentDirectory (buf);
593 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
594 SetCurrentDirectory (cwd);
597 cygwin_conv_to_posix_path (buf, ppath);
598 so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);
600 so->load_addr = load_addr;
603 strcpy (so->name, ppath);
605 solib_end->next = so;
607 len = strlen (ppath);
608 if (len > max_dll_name_len)
609 max_dll_name_len = len;
613 get_image_name (HANDLE h, void *address, int unicode)
615 static char buf[(2 * MAX_PATH) + 1];
616 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
622 /* Attempt to read the name of the dll that was detected.
623 This is documented to work only when actively debugging
624 a program. It will not work for attached processes. */
628 ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done);
630 /* See if we could read the address of a string, and that the
631 address isn't null. */
633 if (done != sizeof (address_ptr) || !address_ptr)
636 /* Find the length of the string */
639 ReadProcessMemory (h, address_ptr + len * size, &b, size, &done);
642 while ((b[0] != 0 || b[size - 1] != 0) && done == size);
645 ReadProcessMemory (h, address_ptr, buf, len, &done);
648 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
649 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
652 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
658 /* Wait for child to do something. Return pid of child, or -1 in case
659 of error; store status through argument pointer OURSTATUS. */
661 handle_load_dll (void *dummy)
663 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
664 char dll_buf[MAX_PATH + 1];
665 char *dll_name = NULL;
668 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
670 if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))
671 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
675 if (*dll_name == '\0')
676 dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode);
680 register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);
686 handle_unload_dll (void *dummy)
688 DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;
691 for (so = &solib_start; so->next != NULL; so = so->next)
692 if (so->next->load_addr == lpBaseOfDll)
694 struct so_stuff *sodel = so->next;
695 so->next = sodel->next;
699 free_objfile (sodel->objfile);
703 error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);
708 /* Return name of last loaded DLL. */
710 child_solib_loaded_library_pathname (int pid)
712 return !solib_end || !solib_end->name[0] ? NULL : solib_end->name;
715 /* Clear list of loaded DLLs. */
717 child_clear_solibs (void)
719 struct so_stuff *so, *so1 = solib_start.next;
721 while ((so = so1) != NULL)
727 solib_start.next = NULL;
728 solib_start.objfile = NULL;
729 solib_end = &solib_start;
730 max_dll_name_len = sizeof ("DLL Name") - 1;
733 /* Add DLL symbol information. */
734 static struct objfile *
735 solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)
737 struct section_addr_info section_addrs;
739 /* The symbols in a dll are offset by 0x1000, which is the
740 the offset from 0 of the first byte in an image - because
741 of the file header and the section alignment. */
743 if (!name || !name[0])
746 memset (§ion_addrs, 0, sizeof (section_addrs));
747 section_addrs.other[0].name = ".text";
748 section_addrs.other[0].addr = load_addr;
749 return safe_symbol_file_add (name, from_tty, NULL, 0, OBJF_SHARED);
752 /* Load DLL symbol info. */
754 dll_symbol_command (char *args, int from_tty)
760 error ("dll-symbols requires a file name");
763 if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
765 char *newargs = (char *) alloca (n + 4 + 1);
766 strcpy (newargs, args);
767 strcat (newargs, ".dll");
771 safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
774 /* List currently loaded DLLs. */
776 info_dll_command (char *ignore, int from_tty)
778 struct so_stuff *so = &solib_start;
783 printf_filtered ("%*s Load Address\n", -max_dll_name_len, "DLL Name");
784 while ((so = so->next) != NULL)
785 printf_filtered ("%*s %08lx\n", -max_dll_name_len, so->name, so->load_addr);
790 /* Handle DEBUG_STRING output from child process.
791 Cygwin prepends its messages with a "cygwin:". Interpret this as
792 a Cygwin signal. Otherwise just print the string as a warning. */
794 handle_output_debug_string (struct target_waitstatus *ourstatus)
799 if (!target_read_string
800 ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
804 if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
806 if (strncmp (s, "cYg", 3) != 0)
812 int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
813 gotasig = target_signal_from_host (sig);
814 ourstatus->value.sig = gotasig;
816 ourstatus->kind = TARGET_WAITKIND_STOPPED;
823 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
824 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
825 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
828 handle_exception (struct target_waitstatus *ourstatus)
831 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
833 ourstatus->kind = TARGET_WAITKIND_STOPPED;
835 /* Record the context of the current thread */
836 th = thread_rec (current_event.dwThreadId, -1);
840 case EXCEPTION_ACCESS_VIOLATION:
841 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
842 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
844 case STATUS_STACK_OVERFLOW:
845 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
846 ourstatus->value.sig = TARGET_SIGNAL_SEGV;
848 case STATUS_FLOAT_DENORMAL_OPERAND:
849 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
850 ourstatus->value.sig = TARGET_SIGNAL_FPE;
852 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
853 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
854 ourstatus->value.sig = TARGET_SIGNAL_FPE;
856 case STATUS_FLOAT_INEXACT_RESULT:
857 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
858 ourstatus->value.sig = TARGET_SIGNAL_FPE;
860 case STATUS_FLOAT_INVALID_OPERATION:
861 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
862 ourstatus->value.sig = TARGET_SIGNAL_FPE;
864 case STATUS_FLOAT_OVERFLOW:
865 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
866 ourstatus->value.sig = TARGET_SIGNAL_FPE;
868 case STATUS_FLOAT_STACK_CHECK:
869 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
870 ourstatus->value.sig = TARGET_SIGNAL_FPE;
872 case STATUS_FLOAT_UNDERFLOW:
873 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
874 ourstatus->value.sig = TARGET_SIGNAL_FPE;
876 case STATUS_FLOAT_DIVIDE_BY_ZERO:
877 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
878 ourstatus->value.sig = TARGET_SIGNAL_FPE;
880 case STATUS_INTEGER_DIVIDE_BY_ZERO:
881 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
882 ourstatus->value.sig = TARGET_SIGNAL_FPE;
884 case STATUS_INTEGER_OVERFLOW:
885 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
886 ourstatus->value.sig = TARGET_SIGNAL_FPE;
888 case EXCEPTION_BREAKPOINT:
889 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
890 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
893 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
894 ourstatus->value.sig = TARGET_SIGNAL_INT;
896 case DBG_CONTROL_BREAK:
897 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
898 ourstatus->value.sig = TARGET_SIGNAL_INT;
900 case EXCEPTION_SINGLE_STEP:
901 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
902 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
904 case EXCEPTION_ILLEGAL_INSTRUCTION:
905 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
906 ourstatus->value.sig = TARGET_SIGNAL_ILL;
908 case EXCEPTION_PRIV_INSTRUCTION:
909 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
910 ourstatus->value.sig = TARGET_SIGNAL_ILL;
912 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
913 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
914 ourstatus->value.sig = TARGET_SIGNAL_ILL;
917 if (current_event.u.Exception.dwFirstChance)
919 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
920 current_event.u.Exception.ExceptionRecord.ExceptionCode,
921 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
922 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
926 last_sig = ourstatus->value.sig;
930 /* Resume all artificially suspended threads if we are continuing
933 child_continue (DWORD continue_status, int id)
939 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
940 current_event.dwProcessId, current_event.dwThreadId,
941 continue_status == DBG_CONTINUE ?
942 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
943 res = ContinueDebugEvent (current_event.dwProcessId,
944 current_event.dwThreadId,
948 for (th = &thread_head; (th = th->next) != NULL;)
949 if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
952 for (i = 0; i < th->suspend_count; i++)
953 (void) ResumeThread (th->h);
954 th->suspend_count = 0;
955 if (debug_registers_changed)
957 /* Only change the value of the debug reisters */
958 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
959 th->context.Dr0 = dr[0];
960 th->context.Dr1 = dr[1];
961 th->context.Dr2 = dr[2];
962 th->context.Dr3 = dr[3];
963 /* th->context.Dr6 = dr[6];
964 FIXME: should we set dr6 also ?? */
965 th->context.Dr7 = dr[7];
966 CHECK (SetThreadContext (th->h, &th->context));
967 th->context.ContextFlags = 0;
971 debug_registers_changed = 0;
975 /* Get the next event from the child. Return 1 if the event requires
976 handling by WFI (or whatever).
979 get_child_debug_event (int pid, struct target_waitstatus *ourstatus)
982 DWORD continue_status, event_code;
983 thread_info *th = NULL;
984 static thread_info dummy_thread_info;
987 last_sig = TARGET_SIGNAL_0;
989 if (!(debug_event = WaitForDebugEvent (¤t_event, 1000)))
993 continue_status = DBG_CONTINUE;
995 event_code = current_event.dwDebugEventCode;
996 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1000 case CREATE_THREAD_DEBUG_EVENT:
1001 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1002 (unsigned) current_event.dwProcessId,
1003 (unsigned) current_event.dwThreadId,
1004 "CREATE_THREAD_DEBUG_EVENT"));
1005 if (saw_create != 1)
1007 /* Record the existence of this thread */
1008 th = child_add_thread (current_event.dwThreadId,
1009 current_event.u.CreateThread.hThread);
1011 printf_unfiltered ("[New %s]\n",
1013 pid_to_ptid (current_event.dwThreadId)));
1014 retval = current_event.dwThreadId;
1017 case EXIT_THREAD_DEBUG_EVENT:
1018 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1019 (unsigned) current_event.dwProcessId,
1020 (unsigned) current_event.dwThreadId,
1021 "EXIT_THREAD_DEBUG_EVENT"));
1022 if (saw_create != 1)
1024 child_delete_thread (current_event.dwThreadId);
1025 th = &dummy_thread_info;
1028 case CREATE_PROCESS_DEBUG_EVENT:
1029 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1030 (unsigned) current_event.dwProcessId,
1031 (unsigned) current_event.dwThreadId,
1032 "CREATE_PROCESS_DEBUG_EVENT"));
1033 CloseHandle (current_event.u.CreateProcessInfo.hFile);
1034 if (++saw_create != 1)
1036 CloseHandle (current_event.u.CreateProcessInfo.hProcess);
1040 current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1041 main_thread_id = current_event.dwThreadId;
1042 /* Add the main thread */
1044 th = child_add_thread (current_event.dwProcessId,
1045 current_event.u.CreateProcessInfo.hProcess);
1047 th = child_add_thread (main_thread_id,
1048 current_event.u.CreateProcessInfo.hThread);
1049 retval = ourstatus->value.related_pid = current_event.dwThreadId;
1052 case EXIT_PROCESS_DEBUG_EVENT:
1053 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1054 (unsigned) current_event.dwProcessId,
1055 (unsigned) current_event.dwThreadId,
1056 "EXIT_PROCESS_DEBUG_EVENT"));
1057 if (saw_create != 1)
1059 ourstatus->kind = TARGET_WAITKIND_EXITED;
1060 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1061 CloseHandle (current_process_handle);
1062 retval = main_thread_id;
1065 case LOAD_DLL_DEBUG_EVENT:
1066 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1067 (unsigned) current_event.dwProcessId,
1068 (unsigned) current_event.dwThreadId,
1069 "LOAD_DLL_DEBUG_EVENT"));
1070 CloseHandle (current_event.u.LoadDll.hFile);
1071 if (saw_create != 1)
1073 catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1074 registers_changed (); /* mark all regs invalid */
1075 ourstatus->kind = TARGET_WAITKIND_LOADED;
1076 ourstatus->value.integer = 0;
1077 retval = main_thread_id;
1080 case UNLOAD_DLL_DEBUG_EVENT:
1081 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1082 (unsigned) current_event.dwProcessId,
1083 (unsigned) current_event.dwThreadId,
1084 "UNLOAD_DLL_DEBUG_EVENT"));
1085 if (saw_create != 1)
1087 catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1088 registers_changed (); /* mark all regs invalid */
1089 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1090 does not exist yet. */
1093 case EXCEPTION_DEBUG_EVENT:
1094 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1095 (unsigned) current_event.dwProcessId,
1096 (unsigned) current_event.dwThreadId,
1097 "EXCEPTION_DEBUG_EVENT"));
1098 if (saw_create != 1)
1100 if (handle_exception (ourstatus))
1101 retval = current_event.dwThreadId;
1104 case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
1105 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1106 (unsigned) current_event.dwProcessId,
1107 (unsigned) current_event.dwThreadId,
1108 "OUTPUT_DEBUG_STRING_EVENT"));
1109 if (saw_create != 1)
1111 if (handle_output_debug_string (ourstatus))
1112 retval = main_thread_id;
1116 if (saw_create != 1)
1118 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1119 (DWORD) current_event.dwProcessId,
1120 (DWORD) current_event.dwThreadId);
1121 printf_unfiltered (" unknown event code %ld\n",
1122 current_event.dwDebugEventCode);
1126 if (!retval || saw_create != 1)
1127 CHECK (child_continue (continue_status, -1));
1130 current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);
1131 inferior_ptid = pid_to_ptid (retval);
1138 /* Wait for interesting events to occur in the target process. */
1140 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1142 int pid = PIDGET (ptid);
1144 /* We loop when we get a non-standard exception rather than return
1145 with a SPURIOUS because resume can try and step or modify things,
1146 which needs a current_thread->h. But some of these exceptions mark
1147 the birth or death of threads, which mean that the current thread
1148 isn't necessarily what you think it is. */
1152 int retval = get_child_debug_event (pid, ourstatus);
1154 return pid_to_ptid (retval);
1159 if (ui_loop_hook != NULL)
1160 detach = ui_loop_hook (0);
1163 child_kill_inferior ();
1169 do_initial_child_stuff (DWORD pid)
1171 extern int stop_after_trap;
1174 last_sig = TARGET_SIGNAL_0;
1176 exception_count = 0;
1177 debug_registers_changed = 0;
1178 debug_registers_used = 0;
1179 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1181 current_event.dwProcessId = pid;
1182 memset (¤t_event, 0, sizeof (current_event));
1183 push_target (&child_ops);
1184 child_init_thread_list ();
1185 child_clear_solibs ();
1186 clear_proceed_status ();
1187 init_wait_for_inferior ();
1189 target_terminal_init ();
1190 target_terminal_inferior ();
1194 stop_after_trap = 1;
1195 wait_for_inferior ();
1196 if (stop_signal != TARGET_SIGNAL_TRAP)
1197 resume (0, stop_signal);
1201 stop_after_trap = 0;
1205 /* Since Windows XP, detaching from a process is supported by Windows.
1206 The following code tries loading the appropriate functions dynamically.
1207 If loading these functions succeeds use them to actually detach from
1208 the inferior process, otherwise behave as usual, pretending that
1209 detach has worked. */
1210 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1211 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1214 has_detach_ability ()
1216 static HMODULE kernel32 = NULL;
1219 kernel32 = LoadLibrary ("kernel32.dll");
1222 if (!DebugSetProcessKillOnExit)
1223 DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1224 "DebugSetProcessKillOnExit");
1225 if (!DebugActiveProcessStop)
1226 DebugActiveProcessStop = GetProcAddress (kernel32,
1227 "DebugActiveProcessStop");
1228 if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1234 /* Attach to process PID, then initialize for debugging it. */
1236 child_attach (char *args, int from_tty)
1242 error_no_arg ("process-id to attach");
1244 pid = strtoul (args, 0, 0);
1245 ok = DebugActiveProcess (pid);
1248 error ("Can't attach to process.");
1250 if (has_detach_ability ())
1253 DebugSetProcessKillOnExit (FALSE);
1258 char *exec_file = (char *) get_exec_file (0);
1261 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1262 target_pid_to_str (pid_to_ptid (pid)));
1264 printf_unfiltered ("Attaching to %s\n",
1265 target_pid_to_str (pid_to_ptid (pid)));
1267 gdb_flush (gdb_stdout);
1270 do_initial_child_stuff (pid);
1271 target_terminal_ours ();
1275 child_detach (char *args, int from_tty)
1279 if (has_detach_ability ())
1281 delete_command (NULL, 0);
1282 child_continue (DBG_CONTINUE, -1);
1283 if (!DebugActiveProcessStop (current_event.dwProcessId))
1285 error ("Can't detach process %lu (error %lu)",
1286 current_event.dwProcessId, GetLastError ());
1289 DebugSetProcessKillOnExit (FALSE);
1291 if (detached && from_tty)
1293 char *exec_file = get_exec_file (0);
1296 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1297 current_event.dwProcessId);
1298 gdb_flush (gdb_stdout);
1300 inferior_ptid = null_ptid;
1301 unpush_target (&child_ops);
1304 /* Print status information about what we're accessing. */
1307 child_files_info (struct target_ops *ignore)
1309 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1310 attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1315 child_open (char *arg, int from_tty)
1317 error ("Use the \"run\" command to start a Unix child process.");
1320 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1321 EXEC_FILE is the file to run.
1322 ALLARGS is a string containing the arguments to the program.
1323 ENV is the environment vector to pass. Errors reported with error(). */
1326 child_create_inferior (char *exec_file, char *allargs, char **env)
1333 PROCESS_INFORMATION pi;
1337 char real_path[MAXPATHLEN];
1341 error ("No executable specified, use `target exec'.\n");
1343 memset (&si, 0, sizeof (si));
1344 si.cb = sizeof (si);
1349 flags |= CREATE_NEW_PROCESS_GROUP;
1352 flags |= CREATE_NEW_CONSOLE;
1354 if (!useshell || !shell[0])
1356 flags = DEBUG_ONLY_THIS_PROCESS;
1357 cygwin_conv_to_win32_path (exec_file, real_path);
1362 char *newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file) + strlen (allargs) + 2);
1363 sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1364 allargs = newallargs;
1366 flags = DEBUG_PROCESS;
1369 args = alloca (strlen (toexec) + strlen (allargs) + 2);
1370 strcpy (args, toexec);
1372 strcat (args, allargs);
1374 /* Prepare the environment vars for CreateProcess. */
1376 /* This code use to assume all env vars were file names and would
1377 translate them all to win32 style. That obviously doesn't work in the
1378 general case. The current rule is that we only translate PATH.
1379 We need to handle PATH because we're about to call CreateProcess and
1380 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1381 in both posix and win32 environments. cygwin.dll will change it back
1382 to posix style if necessary. */
1384 static const char *conv_path_names[] =
1390 /* CreateProcess takes the environment list as a null terminated set of
1391 strings (i.e. two nulls terminate the list). */
1393 /* Get total size for env strings. */
1394 for (envlen = 0, i = 0; env[i] && *env[i]; i++)
1398 for (j = 0; conv_path_names[j]; j++)
1400 len = strlen (conv_path_names[j]);
1401 if (strncmp (conv_path_names[j], env[i], len) == 0)
1403 if (cygwin_posix_path_list_p (env[i] + len))
1405 + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
1407 envlen += strlen (env[i]) + 1;
1411 if (conv_path_names[j] == NULL)
1412 envlen += strlen (env[i]) + 1;
1415 winenv = alloca (envlen + 1);
1417 /* Copy env strings into new buffer. */
1418 for (temp = winenv, i = 0; env[i] && *env[i]; i++)
1422 for (j = 0; conv_path_names[j]; j++)
1424 len = strlen (conv_path_names[j]);
1425 if (strncmp (conv_path_names[j], env[i], len) == 0)
1427 if (cygwin_posix_path_list_p (env[i] + len))
1429 memcpy (temp, env[i], len);
1430 cygwin_posix_to_win32_path_list (env[i] + len, temp + len);
1433 strcpy (temp, env[i]);
1437 if (conv_path_names[j] == NULL)
1438 strcpy (temp, env[i]);
1440 temp += strlen (temp) + 1;
1443 /* Final nil string to terminate new env. */
1447 ret = CreateProcess (0,
1448 args, /* command line */
1449 NULL, /* Security */
1451 TRUE, /* inherit handles */
1452 flags, /* start flags */
1454 NULL, /* current directory */
1458 error ("Error creating process %s, (error %d)\n", exec_file, GetLastError ());
1460 CloseHandle (pi.hThread);
1461 CloseHandle (pi.hProcess);
1463 if (useshell && shell[0] != '\0')
1468 do_initial_child_stuff (pi.dwProcessId);
1470 /* child_continue (DBG_CONTINUE, -1); */
1471 proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
1475 child_mourn_inferior (void)
1477 (void) child_continue (DBG_CONTINUE, -1);
1478 i386_cleanup_dregs();
1479 unpush_target (&child_ops);
1480 generic_mourn_inferior ();
1483 /* Send a SIGINT to the process group. This acts just like the user typed a
1484 ^C on the controlling terminal. */
1489 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1490 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1491 registers_changed (); /* refresh register state */
1495 child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
1496 int write, struct mem_attrib *mem,
1497 struct target_ops *target)
1502 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1503 len, (DWORD) memaddr));
1504 WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,
1506 FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);
1510 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1511 len, (DWORD) memaddr));
1512 ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our, len,
1519 child_kill_inferior (void)
1521 CHECK (TerminateProcess (current_process_handle, 0));
1525 if (!child_continue (DBG_CONTINUE, -1))
1527 if (!WaitForDebugEvent (¤t_event, INFINITE))
1529 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1533 CHECK (CloseHandle (current_process_handle));
1535 /* this may fail in an attached process so don't check. */
1536 (void) CloseHandle (current_thread->h);
1537 target_mourn_inferior (); /* or just child_mourn_inferior? */
1541 child_resume (ptid_t ptid, int step, enum target_signal sig)
1544 DWORD continue_status = DBG_CONTINUE;
1546 int pid = PIDGET (ptid);
1548 if (sig != TARGET_SIGNAL_0)
1550 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1552 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1554 else if (sig == last_sig)
1555 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1558 /* This code does not seem to work, because
1559 the kernel does probably not consider changes in the ExceptionRecord
1560 structure when passing the exception to the inferior.
1561 Note that this seems possible in the exception handler itself. */
1564 for (i = 0; xlate[i].them != -1; i++)
1565 if (xlate[i].us == sig)
1567 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1569 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1572 if (continue_status == DBG_CONTINUE)
1574 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1578 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1582 last_sig = TARGET_SIGNAL_0;
1584 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1587 /* Get context for currently selected thread */
1588 th = thread_rec (current_event.dwThreadId, FALSE);
1593 /* Single step by setting t bit */
1594 child_fetch_inferior_registers (PS_REGNUM);
1595 th->context.EFlags |= FLAG_TRACE_BIT;
1598 if (th->context.ContextFlags)
1600 if (debug_registers_changed)
1602 th->context.Dr0 = dr[0];
1603 th->context.Dr1 = dr[1];
1604 th->context.Dr2 = dr[2];
1605 th->context.Dr3 = dr[3];
1606 /* th->context.Dr6 = dr[6];
1607 FIXME: should we set dr6 also ?? */
1608 th->context.Dr7 = dr[7];
1610 CHECK (SetThreadContext (th->h, &th->context));
1611 th->context.ContextFlags = 0;
1615 /* Allow continuing with the same signal that interrupted us.
1616 Otherwise complain. */
1618 child_continue (continue_status, pid);
1622 child_prepare_to_store (void)
1624 /* Do nothing, since we can store individual regs */
1628 child_can_run (void)
1636 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1637 PIDGET (inferior_ptid)));
1640 struct target_ops child_ops;
1643 init_child_ops (void)
1645 child_ops.to_shortname = "child";
1646 child_ops.to_longname = "Win32 child process";
1647 child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
1648 child_ops.to_open = child_open;
1649 child_ops.to_close = child_close;
1650 child_ops.to_attach = child_attach;
1651 child_ops.to_detach = child_detach;
1652 child_ops.to_resume = child_resume;
1653 child_ops.to_wait = child_wait;
1654 child_ops.to_fetch_registers = child_fetch_inferior_registers;
1655 child_ops.to_store_registers = child_store_inferior_registers;
1656 child_ops.to_prepare_to_store = child_prepare_to_store;
1657 child_ops.to_xfer_memory = child_xfer_memory;
1658 child_ops.to_files_info = child_files_info;
1659 child_ops.to_insert_breakpoint = memory_insert_breakpoint;
1660 child_ops.to_remove_breakpoint = memory_remove_breakpoint;
1661 child_ops.to_terminal_init = terminal_init_inferior;
1662 child_ops.to_terminal_inferior = terminal_inferior;
1663 child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1664 child_ops.to_terminal_ours = terminal_ours;
1665 child_ops.to_terminal_info = child_terminal_info;
1666 child_ops.to_kill = child_kill_inferior;
1667 child_ops.to_load = 0;
1668 child_ops.to_lookup_symbol = 0;
1669 child_ops.to_create_inferior = child_create_inferior;
1670 child_ops.to_mourn_inferior = child_mourn_inferior;
1671 child_ops.to_can_run = child_can_run;
1672 child_ops.to_notice_signals = 0;
1673 child_ops.to_thread_alive = win32_child_thread_alive;
1674 child_ops.to_pid_to_str = cygwin_pid_to_str;
1675 child_ops.to_stop = child_stop;
1676 child_ops.to_stratum = process_stratum;
1677 child_ops.DONT_USE = 0;
1678 child_ops.to_has_all_memory = 1;
1679 child_ops.to_has_memory = 1;
1680 child_ops.to_has_stack = 1;
1681 child_ops.to_has_registers = 1;
1682 child_ops.to_has_execution = 1;
1683 child_ops.to_sections = 0;
1684 child_ops.to_sections_end = 0;
1685 child_ops.to_magic = OPS_MAGIC;
1689 _initialize_inftarg (void)
1691 struct cmd_list_element *c;
1696 c = add_com ("dll-symbols", class_files, dll_symbol_command,
1697 "Load dll library symbols from FILE.");
1698 c->completer = filename_completer;
1700 sh = getenv ("SHELL");
1703 if (access (sh, X_OK) != 0)
1710 cygwin_conv_to_win32_path (sh, shell);
1714 add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
1716 add_show_from_set (add_set_cmd ("shell", class_support, var_boolean,
1718 "Set use of shell to start subprocess.",
1722 add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,
1723 (char *) &new_console,
1724 "Set creation of new console when creating child process.",
1728 add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,
1729 (char *) &new_group,
1730 "Set creation of new group when creating child process.",
1734 add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,
1735 (char *) &debug_exec,
1736 "Set whether to display execution in child process.",
1740 add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,
1741 (char *) &debug_events,
1742 "Set whether to display kernel events in child process.",
1746 add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,
1747 (char *) &debug_memory,
1748 "Set whether to display memory accesses in child process.",
1752 add_show_from_set (add_set_cmd ("debugexceptions", class_support, var_boolean,
1753 (char *) &debug_exceptions,
1754 "Set whether to display kernel exceptions in child process.",
1758 add_info ("dll", info_dll_command, "Status of loaded DLLs.");
1759 add_info_alias ("sharedlibrary", "dll", 1);
1761 add_target (&child_ops);
1764 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1766 /* Pass the address ADDR to the inferior in the I'th debug register.
1767 Here we just store the address in dr array, the registers will be
1768 actually set up when child_continue is called. */
1770 cygwin_set_dr (int i, CORE_ADDR addr)
1773 internal_error (__FILE__, __LINE__,
1774 "Invalid register %d in cygwin_set_dr.\n", i);
1775 dr[i] = (unsigned) addr;
1776 debug_registers_changed = 1;
1777 debug_registers_used = 1;
1780 /* Pass the value VAL to the inferior in the DR7 debug control
1781 register. Here we just store the address in D_REGS, the watchpoint
1782 will be actually set up in child_wait. */
1784 cygwin_set_dr7 (unsigned val)
1787 debug_registers_changed = 1;
1788 debug_registers_used = 1;
1791 /* Get the value of the DR6 debug status register from the inferior.
1792 Here we just return the value stored in dr[6]
1793 by the last call to thread_rec for current_event.dwThreadId id. */
1795 cygwin_get_dr6 (void)
1801 /* Determine if the thread referenced by "pid" is alive
1802 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1803 it means that the pid has died. Otherwise it is assumed to be alive. */
1805 win32_child_thread_alive (ptid_t ptid)
1807 int pid = PIDGET (ptid);
1809 return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
1813 /* Convert pid to printable format. */
1815 cygwin_pid_to_str (ptid_t ptid)
1817 static char buf[80];
1818 int pid = PIDGET (ptid);
1820 if ((DWORD) pid == current_event.dwProcessId)
1821 sprintf (buf, "process %d", pid);
1823 sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
1828 core_dll_symbols_add (char *dll_name, DWORD base_addr)
1830 struct objfile *objfile;
1831 char *objfile_basename;
1832 const char *dll_basename;
1834 if (!(dll_basename = strrchr (dll_name, '/')))
1835 dll_basename = dll_name;
1839 ALL_OBJFILES (objfile)
1841 objfile_basename = strrchr (objfile->name, '/');
1843 if (objfile_basename &&
1844 strcmp (dll_basename, objfile_basename + 1) == 0)
1846 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1847 base_addr, dll_name);
1852 register_loaded_dll (dll_name, base_addr + 0x1000);
1853 solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);
1861 struct target_ops *target;
1864 map_code_section_args;
1867 map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)
1871 struct section_table *new_target_sect_ptr;
1873 map_code_section_args *args = (map_code_section_args *) obj;
1874 struct target_ops *target = args->target;
1875 if (sect->flags & SEC_CODE)
1877 update_coreops = core_ops.to_sections == target->to_sections;
1879 if (target->to_sections)
1881 old = target->to_sections_end - target->to_sections;
1882 target->to_sections = (struct section_table *)
1883 xrealloc ((char *) target->to_sections,
1884 (sizeof (struct section_table)) * (1 + old));
1889 target->to_sections = (struct section_table *)
1890 xmalloc ((sizeof (struct section_table)));
1892 target->to_sections_end = target->to_sections + (1 + old);
1894 /* Update the to_sections field in the core_ops structure
1898 core_ops.to_sections = target->to_sections;
1899 core_ops.to_sections_end = target->to_sections_end;
1901 new_target_sect_ptr = target->to_sections + old;
1902 new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
1903 new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
1904 bfd_section_size (abfd, sect);;
1905 new_target_sect_ptr->the_bfd_section = sect;
1906 new_target_sect_ptr->bfd = abfd;
1911 dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
1914 map_code_section_args map_args;
1915 asection *lowest_sect;
1917 if (dll_name == NULL || target == NULL)
1919 name = xstrdup (dll_name);
1920 dll_bfd = bfd_openr (name, "pei-i386");
1921 if (dll_bfd == NULL)
1924 if (bfd_check_format (dll_bfd, bfd_object))
1926 lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
1927 if (lowest_sect == NULL)
1929 map_args.target = target;
1930 map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
1932 bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
1939 core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)
1941 struct target_ops *target = (struct target_ops *) obj;
1946 char *dll_name = NULL;
1948 struct win32_pstatus *pstatus;
1951 if (strncmp (sect->name, ".module", 7))
1954 buf = (char *) xmalloc (sect->_raw_size + 1);
1957 printf_unfiltered ("memory allocation failed for %s\n", sect->name);
1960 if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))
1963 pstatus = (struct win32_pstatus *) buf;
1965 memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
1966 dll_name_size = pstatus->data.module_info.module_name_size;
1967 if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)
1970 dll_name = (char *) xmalloc (dll_name_size + 1);
1973 printf_unfiltered ("memory allocation failed for %s\n", sect->name);
1976 strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);
1978 while ((p = strchr (dll_name, '\\')))
1981 if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))
1982 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);
1984 if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))
1985 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
1996 child_solib_add (char *filename, int from_tty, struct target_ops *target,
2003 child_clear_solibs ();
2004 bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);
2008 if (solib_end && solib_end->name)
2009 solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,
2010 solib_end->load_addr);
2015 fetch_elf_core_registers (char *core_reg_sect,
2016 unsigned core_reg_size,
2021 if (core_reg_size < sizeof (CONTEXT))
2023 error ("Core file register section too small (%u bytes).", core_reg_size);
2026 for (r = 0; r < NUM_REGS; r++)
2027 supply_register (r, core_reg_sect + mappings[r]);
2030 static struct core_fns win32_elf_core_fns =
2032 bfd_target_elf_flavour,
2033 default_check_format,
2034 default_core_sniffer,
2035 fetch_elf_core_registers,
2040 _initialize_core_win32 (void)
2042 add_core_fns (&win32_elf_core_fns);
2046 _initialize_check_for_gdb_ini (void)
2049 if (inhibit_gdbinit)
2052 homedir = getenv ("HOME");
2056 char *oldini = (char *) alloca (strlen (homedir) +
2057 sizeof ("/gdb.ini"));
2058 strcpy (oldini, homedir);
2059 p = strchr (oldini, '\0');
2060 if (p > oldini && p[-1] != '/')
2062 strcpy (p, "gdb.ini");
2063 if (access (oldini, 0) == 0)
2065 int len = strlen (oldini);
2066 char *newini = alloca (len + 1);
2067 sprintf (newini, "%.*s.gdbinit",
2068 (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2069 warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);