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 /* 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 x
90 #define DEBUG_EVENTS(x) if (debug_events) printf x
91 #define DEBUG_MEM(x) if (debug_memory) printf x
92 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf 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 int last_sig
= 0; /* Set if a signal was received from the
103 /* Thread information structure used to track information that is
104 not available in gdb's thread structure. */
105 typedef struct thread_info_struct
107 struct thread_info_struct
*next
;
117 static thread_info thread_head
;
119 /* The process and thread handles for the above context. */
121 static DEBUG_EVENT current_event
; /* The current debug event from
123 static HANDLE current_process_handle
; /* Currently executing process */
124 static thread_info
*current_thread
; /* Info on currently selected thread */
125 static DWORD main_thread_id
; /* Thread ID of the main thread */
127 /* Counts of things. */
128 static int exception_count
= 0;
129 static int event_count
= 0;
132 static int new_console
= 0;
133 static int new_group
= 1;
134 static int debug_exec
= 0; /* show execution */
135 static int debug_events
= 0; /* show events from kernel */
136 static int debug_memory
= 0; /* show target memory accesses */
137 static int debug_exceptions
= 0; /* show target exceptions */
139 /* This vector maps GDB's idea of a register's number into an address
140 in the win32 exception context vector.
142 It also contains the bit mask needed to load the register in question.
144 One day we could read a reg, we could inspect the context we
145 already have loaded, if it doesn't have the bit set that we need,
146 we read that set of registers in using GetThreadContext. If the
147 context already contains what we need, we just unpack it. Then to
148 write a register, first we have to ensure that the context contains
149 the other regs of the group, and then we copy the info in and set
152 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
153 static const int mappings
[] =
155 context_offset (Eax
),
156 context_offset (Ecx
),
157 context_offset (Edx
),
158 context_offset (Ebx
),
159 context_offset (Esp
),
160 context_offset (Ebp
),
161 context_offset (Esi
),
162 context_offset (Edi
),
163 context_offset (Eip
),
164 context_offset (EFlags
),
165 context_offset (SegCs
),
166 context_offset (SegSs
),
167 context_offset (SegDs
),
168 context_offset (SegEs
),
169 context_offset (SegFs
),
170 context_offset (SegGs
),
171 context_offset (FloatSave
.RegisterArea
[0 * 10]),
172 context_offset (FloatSave
.RegisterArea
[1 * 10]),
173 context_offset (FloatSave
.RegisterArea
[2 * 10]),
174 context_offset (FloatSave
.RegisterArea
[3 * 10]),
175 context_offset (FloatSave
.RegisterArea
[4 * 10]),
176 context_offset (FloatSave
.RegisterArea
[5 * 10]),
177 context_offset (FloatSave
.RegisterArea
[6 * 10]),
178 context_offset (FloatSave
.RegisterArea
[7 * 10]),
179 context_offset (FloatSave
.ControlWord
),
180 context_offset (FloatSave
.StatusWord
),
181 context_offset (FloatSave
.TagWord
),
182 context_offset (FloatSave
.ErrorSelector
),
183 context_offset (FloatSave
.ErrorOffset
),
184 context_offset (FloatSave
.DataSelector
),
185 context_offset (FloatSave
.DataOffset
),
186 context_offset (FloatSave
.ErrorSelector
)
189 context_offset (ExtendedRegisters
[10*16]),
190 context_offset (ExtendedRegisters
[11*16]),
191 context_offset (ExtendedRegisters
[12*16]),
192 context_offset (ExtendedRegisters
[13*16]),
193 context_offset (ExtendedRegisters
[14*16]),
194 context_offset (ExtendedRegisters
[15*16]),
195 context_offset (ExtendedRegisters
[16*16]),
196 context_offset (ExtendedRegisters
[17*16]),
198 context_offset (ExtendedRegisters
[24])
202 #undef context_offset
204 /* This vector maps the target's idea of an exception (extracted
205 from the DEBUG_EVENT structure) to GDB's idea. */
207 struct xlate_exception
210 enum target_signal us
;
213 static const struct xlate_exception
216 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
217 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
218 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
219 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
220 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
224 check (BOOL ok
, const char *file
, int line
)
227 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
232 /* Find a thread record given a thread id.
233 If get_context then also retrieve the context for this
236 thread_rec (DWORD id
, int get_context
)
240 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
243 if (!th
->suspend_count
&& get_context
)
245 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
246 th
->suspend_count
= SuspendThread (th
->h
) + 1;
247 else if (get_context
< 0)
248 th
->suspend_count
= -1;
250 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
251 GetThreadContext (th
->h
, &th
->context
);
252 if (id
== current_event
.dwThreadId
)
254 /* Copy dr values from that thread. */
255 dr
[0] = th
->context
.Dr0
;
256 dr
[1] = th
->context
.Dr1
;
257 dr
[2] = th
->context
.Dr2
;
258 dr
[3] = th
->context
.Dr3
;
259 dr
[6] = th
->context
.Dr6
;
260 dr
[7] = th
->context
.Dr7
;
269 /* Add a thread to the thread list */
271 child_add_thread (DWORD id
, HANDLE h
)
275 if ((th
= thread_rec (id
, FALSE
)))
278 th
= (thread_info
*) xmalloc (sizeof (*th
));
279 memset (th
, 0, sizeof (*th
));
282 th
->next
= thread_head
.next
;
283 thread_head
.next
= th
;
284 add_thread (pid_to_ptid (id
));
285 /* Set the debug registers for the new thread in they are used. */
286 if (debug_registers_used
)
288 /* Only change the value of the debug registers. */
289 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
290 CHECK (GetThreadContext (th
->h
, &th
->context
));
291 th
->context
.Dr0
= dr
[0];
292 th
->context
.Dr1
= dr
[1];
293 th
->context
.Dr2
= dr
[2];
294 th
->context
.Dr3
= dr
[3];
295 /* th->context.Dr6 = dr[6];
296 FIXME: should we set dr6 also ?? */
297 th
->context
.Dr7
= dr
[7];
298 CHECK (SetThreadContext (th
->h
, &th
->context
));
299 th
->context
.ContextFlags
= 0;
304 /* Clear out any old thread list and reintialize it to a
307 child_init_thread_list (void)
309 thread_info
*th
= &thread_head
;
311 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
313 while (th
->next
!= NULL
)
315 thread_info
*here
= th
->next
;
316 th
->next
= here
->next
;
317 (void) CloseHandle (here
->h
);
322 /* Delete a thread from the list of threads */
324 child_delete_thread (DWORD id
)
329 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
330 delete_thread (pid_to_ptid (id
));
332 for (th
= &thread_head
;
333 th
->next
!= NULL
&& th
->next
->id
!= id
;
337 if (th
->next
!= NULL
)
339 thread_info
*here
= th
->next
;
340 th
->next
= here
->next
;
341 CloseHandle (here
->h
);
347 do_child_fetch_inferior_registers (int r
)
349 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
353 l
= *((long *) context_offset
) & 0xffff;
354 supply_register (r
, (char *) &l
);
356 else if (r
== FOP_REGNUM
)
358 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
359 supply_register (r
, (char *) &l
);
362 supply_register (r
, context_offset
);
365 for (r
= 0; r
< NUM_REGS
; r
++)
366 do_child_fetch_inferior_registers (r
);
371 child_fetch_inferior_registers (int r
)
373 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
374 do_child_fetch_inferior_registers (r
);
378 do_child_store_inferior_registers (int r
)
381 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
384 for (r
= 0; r
< NUM_REGS
; r
++)
385 do_child_store_inferior_registers (r
);
389 /* Store a new register value into the current thread context */
391 child_store_inferior_registers (int r
)
393 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
394 do_child_store_inferior_registers (r
);
397 static int psapi_loaded
= 0;
398 static HMODULE psapi_module_handle
= NULL
;
399 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
400 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
401 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
404 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
410 HMODULE
*DllHandle
= dh_buf
;
415 psapi_EnumProcessModules
== NULL
||
416 psapi_GetModuleInformation
== NULL
||
417 psapi_GetModuleFileNameExA
== NULL
)
422 psapi_module_handle
= LoadLibrary ("psapi.dll");
423 if (!psapi_module_handle
)
425 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
428 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
429 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
430 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
431 "GetModuleFileNameExA");
432 if (psapi_EnumProcessModules
== NULL
||
433 psapi_GetModuleInformation
== NULL
||
434 psapi_GetModuleFileNameExA
== NULL
)
439 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
444 if (!ok
|| !cbNeeded
)
447 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
451 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
458 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
460 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
464 error ("Can't get module info");
466 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
471 error ("Error getting dll name: %u\n", GetLastError ());
473 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
478 dll_name_ret
[0] = '\0';
482 /* Encapsulate the information required in a call to
483 symbol_file_add_args */
484 struct safe_symbol_file_add_args
488 struct section_addr_info
*addrs
;
491 struct ui_file
*err
, *out
;
495 /* Maintain a linked list of "so" information. */
498 struct so_stuff
*next
;
501 struct objfile
*objfile
;
503 } solib_start
, *solib_end
;
505 /* Call symbol_file_add with stderr redirected. We don't care if there
508 safe_symbol_file_add_stub (void *argv
)
510 #define p ((struct safe_symbol_file_add_args *)argv)
511 struct so_stuff
*so
= &solib_start
;
513 while ((so
= so
->next
))
514 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
516 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
521 /* Restore gdb's stderr after calling symbol_file_add */
523 safe_symbol_file_add_cleanup (void *p
)
525 #define sp ((struct safe_symbol_file_add_args *)p)
526 gdb_flush (gdb_stderr
);
527 gdb_flush (gdb_stdout
);
528 ui_file_delete (gdb_stderr
);
529 ui_file_delete (gdb_stdout
);
530 gdb_stderr
= sp
->err
;
531 gdb_stdout
= sp
->out
;
535 /* symbol_file_add wrapper that prevents errors from being displayed. */
536 static struct objfile
*
537 safe_symbol_file_add (char *name
, int from_tty
,
538 struct section_addr_info
*addrs
,
539 int mainline
, int flags
)
541 struct safe_symbol_file_add_args p
;
542 struct cleanup
*cleanup
;
544 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
548 gdb_flush (gdb_stderr
);
549 gdb_flush (gdb_stdout
);
550 gdb_stderr
= ui_file_new ();
551 gdb_stdout
= ui_file_new ();
553 p
.from_tty
= from_tty
;
555 p
.mainline
= mainline
;
557 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
559 do_cleanups (cleanup
);
563 /* Remember the maximum DLL length for printing in info dll command. */
564 int max_dll_name_len
;
567 register_loaded_dll (const char *name
, DWORD load_addr
)
570 char ppath
[MAX_PATH
+ 1];
571 char buf
[MAX_PATH
+ 1];
572 char cwd
[MAX_PATH
+ 1];
574 WIN32_FIND_DATA w32_fd
;
575 HANDLE h
= FindFirstFile(name
, &w32_fd
);
580 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
582 p
= strrchr (buf
, '\\');
585 SetCurrentDirectory (buf
);
586 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
587 SetCurrentDirectory (cwd
);
590 cygwin_conv_to_posix_path (buf
, ppath
);
591 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
593 so
->load_addr
= load_addr
;
596 strcpy (so
->name
, ppath
);
598 solib_end
->next
= so
;
600 len
= strlen (ppath
);
601 if (len
> max_dll_name_len
)
602 max_dll_name_len
= len
;
605 /* Wait for child to do something. Return pid of child, or -1 in case
606 of error; store status through argument pointer OURSTATUS. */
608 handle_load_dll (void *dummy
)
610 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
613 char dll_buf
[MAX_PATH
+ 1];
614 char *dll_name
= NULL
;
617 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
619 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
620 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
624 /* Attempt to read the name of the dll that was detected.
625 This is documented to work only when actively debugging
626 a program. It will not work for attached processes. */
627 if (dll_name
== NULL
|| *dll_name
== '\0')
629 DWORD size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
633 ReadProcessMemory (current_process_handle
,
634 (LPCVOID
) event
->lpImageName
,
635 (char *) &dll_name_ptr
,
636 sizeof (dll_name_ptr
), &done
);
638 /* See if we could read the address of a string, and that the
639 address isn't null. */
641 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
646 ReadProcessMemory (current_process_handle
,
647 (LPCVOID
) (dll_name_ptr
+ len
* size
),
653 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
655 dll_name
= alloca (len
);
659 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
660 ReadProcessMemory (current_process_handle
,
661 (LPCVOID
) dll_name_ptr
,
663 len
* sizeof (WCHAR
),
666 WideCharToMultiByte (CP_ACP
, 0,
667 unicode_dll_name
, len
,
668 dll_name
, len
, 0, 0);
672 ReadProcessMemory (current_process_handle
,
673 (LPCVOID
) dll_name_ptr
,
683 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
689 handle_unload_dll (void *dummy
)
691 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
694 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
695 if (so
->next
->load_addr
== lpBaseOfDll
)
697 struct so_stuff
*sodel
= so
->next
;
698 so
->next
= sodel
->next
;
702 free_objfile (sodel
->objfile
);
706 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
711 /* Return name of last loaded DLL. */
713 child_solib_loaded_library_pathname (int pid
)
715 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
718 /* Clear list of loaded DLLs. */
720 child_clear_solibs (void)
722 struct so_stuff
*so
, *so1
= solib_start
.next
;
724 while ((so
= so1
) != NULL
)
730 solib_start
.next
= NULL
;
731 solib_start
.objfile
= NULL
;
732 solib_end
= &solib_start
;
733 max_dll_name_len
= sizeof ("DLL Name") - 1;
736 /* Add DLL symbol information. */
737 static struct objfile
*
738 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
740 struct section_addr_info section_addrs
;
742 /* The symbols in a dll are offset by 0x1000, which is the
743 the offset from 0 of the first byte in an image - because
744 of the file header and the section alignment. */
746 if (!name
|| !name
[0])
749 memset (§ion_addrs
, 0, sizeof (section_addrs
));
750 section_addrs
.other
[0].name
= ".text";
751 section_addrs
.other
[0].addr
= load_addr
;
752 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
755 /* Load DLL symbol info. */
757 dll_symbol_command (char *args
, int from_tty
)
763 error ("dll-symbols requires a file name");
766 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
768 char *newargs
= (char *) alloca (n
+ 4 + 1);
769 strcpy (newargs
, args
);
770 strcat (newargs
, ".dll");
774 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
777 /* List currently loaded DLLs. */
779 info_dll_command (char *ignore
, int from_tty
)
781 struct so_stuff
*so
= &solib_start
;
786 printf ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
787 while ((so
= so
->next
) != NULL
)
788 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
793 /* Handle DEBUG_STRING output from child process.
794 Cygwin prepends its messages with a "cygwin:". Interpret this as
795 a Cygwin signal. Otherwise just print the string as a warning. */
797 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
802 if (!target_read_string
803 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
807 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
809 if (strncmp (s
, "cYg", 3) != 0)
815 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
816 gotasig
= target_signal_from_host (sig
);
817 ourstatus
->value
.sig
= gotasig
;
819 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
827 handle_exception (struct target_waitstatus
*ourstatus
)
830 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
832 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
834 /* Record the context of the current thread */
835 th
= thread_rec (current_event
.dwThreadId
, -1);
839 case EXCEPTION_ACCESS_VIOLATION
:
840 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
841 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
842 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
845 case STATUS_FLOAT_UNDERFLOW
:
846 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
847 case STATUS_FLOAT_OVERFLOW
:
848 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
849 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
850 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
851 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
854 case STATUS_STACK_OVERFLOW
:
855 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
856 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
857 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
859 case EXCEPTION_BREAKPOINT
:
860 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
861 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
862 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
865 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
866 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
867 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
868 last_sig
= SIGINT
; /* FIXME - should check pass state */
870 case EXCEPTION_SINGLE_STEP
:
871 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
872 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
873 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
875 case EXCEPTION_ILLEGAL_INSTRUCTION
:
876 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
877 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
878 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
882 if (current_event
.u
.Exception
.dwFirstChance
)
884 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
885 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
886 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
887 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
894 /* Resume all artificially suspended threads if we are continuing
897 child_continue (DWORD continue_status
, int id
)
903 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
904 current_event
.dwProcessId
, current_event
.dwThreadId
));
905 res
= ContinueDebugEvent (current_event
.dwProcessId
,
906 current_event
.dwThreadId
,
910 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
911 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
914 for (i
= 0; i
< th
->suspend_count
; i
++)
915 (void) ResumeThread (th
->h
);
916 th
->suspend_count
= 0;
917 if (debug_registers_changed
)
919 /* Only change the value of the debug reisters */
920 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
921 th
->context
.Dr0
= dr
[0];
922 th
->context
.Dr1
= dr
[1];
923 th
->context
.Dr2
= dr
[2];
924 th
->context
.Dr3
= dr
[3];
925 /* th->context.Dr6 = dr[6];
926 FIXME: should we set dr6 also ?? */
927 th
->context
.Dr7
= dr
[7];
928 CHECK (SetThreadContext (th
->h
, &th
->context
));
929 th
->context
.ContextFlags
= 0;
933 debug_registers_changed
= 0;
937 /* Get the next event from the child. Return 1 if the event requires
938 handling by WFI (or whatever).
941 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
944 DWORD continue_status
, event_code
;
945 thread_info
*th
= NULL
;
946 static thread_info dummy_thread_info
;
951 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
955 continue_status
= DBG_CONTINUE
;
957 event_code
= current_event
.dwDebugEventCode
;
958 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
962 case CREATE_THREAD_DEBUG_EVENT
:
963 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
964 (unsigned) current_event
.dwProcessId
,
965 (unsigned) current_event
.dwThreadId
,
966 "CREATE_THREAD_DEBUG_EVENT"));
967 /* Record the existence of this thread */
968 th
= child_add_thread (current_event
.dwThreadId
,
969 current_event
.u
.CreateThread
.hThread
);
971 printf_unfiltered ("[New %s]\n",
973 pid_to_ptid (current_event
.dwThreadId
)));
974 retval
= current_event
.dwThreadId
;
977 case EXIT_THREAD_DEBUG_EVENT
:
978 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
979 (unsigned) current_event
.dwProcessId
,
980 (unsigned) current_event
.dwThreadId
,
981 "EXIT_THREAD_DEBUG_EVENT"));
982 child_delete_thread (current_event
.dwThreadId
);
983 th
= &dummy_thread_info
;
986 case CREATE_PROCESS_DEBUG_EVENT
:
987 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
988 (unsigned) current_event
.dwProcessId
,
989 (unsigned) current_event
.dwThreadId
,
990 "CREATE_PROCESS_DEBUG_EVENT"));
991 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
992 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
994 main_thread_id
= current_event
.dwThreadId
;
995 /* Add the main thread */
997 th
= child_add_thread (current_event
.dwProcessId
,
998 current_event
.u
.CreateProcessInfo
.hProcess
);
1000 th
= child_add_thread (main_thread_id
,
1001 current_event
.u
.CreateProcessInfo
.hThread
);
1002 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1005 case EXIT_PROCESS_DEBUG_EVENT
:
1006 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1007 (unsigned) current_event
.dwProcessId
,
1008 (unsigned) current_event
.dwThreadId
,
1009 "EXIT_PROCESS_DEBUG_EVENT"));
1010 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1011 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1012 CloseHandle (current_process_handle
);
1013 retval
= main_thread_id
;
1016 case LOAD_DLL_DEBUG_EVENT
:
1017 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1018 (unsigned) current_event
.dwProcessId
,
1019 (unsigned) current_event
.dwThreadId
,
1020 "LOAD_DLL_DEBUG_EVENT"));
1021 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1022 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1023 registers_changed (); /* mark all regs invalid */
1024 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1025 ourstatus
->value
.integer
= 0;
1026 retval
= main_thread_id
;
1029 case UNLOAD_DLL_DEBUG_EVENT
:
1030 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1031 (unsigned) current_event
.dwProcessId
,
1032 (unsigned) current_event
.dwThreadId
,
1033 "UNLOAD_DLL_DEBUG_EVENT"));
1034 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1035 registers_changed (); /* mark all regs invalid */
1036 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1037 does not exist yet. */
1040 case EXCEPTION_DEBUG_EVENT
:
1041 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1042 (unsigned) current_event
.dwProcessId
,
1043 (unsigned) current_event
.dwThreadId
,
1044 "EXCEPTION_DEBUG_EVENT"));
1045 if (handle_exception (ourstatus
))
1046 retval
= current_event
.dwThreadId
;
1049 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1050 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1051 (unsigned) current_event
.dwProcessId
,
1052 (unsigned) current_event
.dwThreadId
,
1053 "OUTPUT_DEBUG_STRING_EVENT"));
1054 if (handle_output_debug_string (ourstatus
))
1055 retval
= main_thread_id
;
1059 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1060 (DWORD
) current_event
.dwProcessId
,
1061 (DWORD
) current_event
.dwThreadId
);
1062 printf_unfiltered (" unknown event code %ld\n",
1063 current_event
.dwDebugEventCode
);
1068 CHECK (child_continue (continue_status
, -1));
1071 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1072 inferior_ptid
= pid_to_ptid (retval
);
1079 /* Wait for interesting events to occur in the target process. */
1081 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1083 int pid
= PIDGET (ptid
);
1085 /* We loop when we get a non-standard exception rather than return
1086 with a SPURIOUS because resume can try and step or modify things,
1087 which needs a current_thread->h. But some of these exceptions mark
1088 the birth or death of threads, which mean that the current thread
1089 isn't necessarily what you think it is. */
1093 int retval
= get_child_debug_event (pid
, ourstatus
);
1095 return pid_to_ptid (retval
);
1100 if (ui_loop_hook
!= NULL
)
1101 detach
= ui_loop_hook (0);
1104 child_kill_inferior ();
1110 do_initial_child_stuff (DWORD pid
)
1112 extern int stop_after_trap
;
1117 exception_count
= 0;
1118 debug_registers_changed
= 0;
1119 debug_registers_used
= 0;
1120 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1122 current_event
.dwProcessId
= pid
;
1123 memset (¤t_event
, 0, sizeof (current_event
));
1124 push_target (&child_ops
);
1125 child_init_thread_list ();
1126 child_clear_solibs ();
1127 clear_proceed_status ();
1128 init_wait_for_inferior ();
1130 target_terminal_init ();
1131 target_terminal_inferior ();
1135 stop_after_trap
= 1;
1136 wait_for_inferior ();
1137 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1138 resume (0, stop_signal
);
1142 stop_after_trap
= 0;
1146 /* Since Windows XP, detaching from a process is supported by Windows.
1147 The following code tries loading the appropriate functions dynamically.
1148 If loading these functions succeeds use them to actually detach from
1149 the inferior process, otherwise behave as usual, pretending that
1150 detach has worked. */
1151 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1152 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1155 has_detach_ability ()
1157 static HMODULE kernel32
= NULL
;
1160 kernel32
= LoadLibrary ("kernel32.dll");
1163 if (!DebugSetProcessKillOnExit
)
1164 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1165 "DebugSetProcessKillOnExit");
1166 if (!DebugActiveProcessStop
)
1167 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1168 "DebugActiveProcessStop");
1169 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1175 /* Attach to process PID, then initialize for debugging it. */
1177 child_attach (char *args
, int from_tty
)
1183 error_no_arg ("process-id to attach");
1185 pid
= strtoul (args
, 0, 0);
1186 ok
= DebugActiveProcess (pid
);
1189 error ("Can't attach to process.");
1191 if (has_detach_ability ())
1194 DebugSetProcessKillOnExit (FALSE
);
1199 char *exec_file
= (char *) get_exec_file (0);
1202 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1203 target_pid_to_str (pid_to_ptid (pid
)));
1205 printf_unfiltered ("Attaching to %s\n",
1206 target_pid_to_str (pid_to_ptid (pid
)));
1208 gdb_flush (gdb_stdout
);
1211 do_initial_child_stuff (pid
);
1212 target_terminal_ours ();
1216 child_detach (char *args
, int from_tty
)
1220 if (has_detach_ability ())
1222 delete_command (NULL
, 0);
1223 child_continue (DBG_CONTINUE
, -1);
1224 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1226 error ("Can't detach process %lu (error %lu)",
1227 current_event
.dwProcessId
, GetLastError ());
1230 DebugSetProcessKillOnExit (FALSE
);
1232 if (detached
&& from_tty
)
1234 char *exec_file
= get_exec_file (0);
1237 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1238 current_event
.dwProcessId
);
1239 gdb_flush (gdb_stdout
);
1241 inferior_ptid
= null_ptid
;
1242 unpush_target (&child_ops
);
1245 /* Print status information about what we're accessing. */
1248 child_files_info (struct target_ops
*ignore
)
1250 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1251 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1256 child_open (char *arg
, int from_tty
)
1258 error ("Use the \"run\" command to start a Unix child process.");
1261 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1262 EXEC_FILE is the file to run.
1263 ALLARGS is a string containing the arguments to the program.
1264 ENV is the environment vector to pass. Errors reported with error(). */
1267 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1269 char real_path
[MAXPATHLEN
];
1275 PROCESS_INFORMATION pi
;
1281 error ("No executable specified, use `target exec'.\n");
1283 memset (&si
, 0, sizeof (si
));
1284 si
.cb
= sizeof (si
);
1286 cygwin_conv_to_win32_path (exec_file
, real_path
);
1288 flags
= DEBUG_ONLY_THIS_PROCESS
;
1291 flags
|= CREATE_NEW_PROCESS_GROUP
;
1294 flags
|= CREATE_NEW_CONSOLE
;
1296 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1298 strcpy (args
, real_path
);
1301 strcat (args
, allargs
);
1303 /* Prepare the environment vars for CreateProcess. */
1305 /* This code use to assume all env vars were file names and would
1306 translate them all to win32 style. That obviously doesn't work in the
1307 general case. The current rule is that we only translate PATH.
1308 We need to handle PATH because we're about to call CreateProcess and
1309 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1310 in both posix and win32 environments. cygwin.dll will change it back
1311 to posix style if necessary. */
1313 static const char *conv_path_names
[] =
1319 /* CreateProcess takes the environment list as a null terminated set of
1320 strings (i.e. two nulls terminate the list). */
1322 /* Get total size for env strings. */
1323 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1327 for (j
= 0; conv_path_names
[j
]; j
++)
1329 len
= strlen (conv_path_names
[j
]);
1330 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1332 if (cygwin_posix_path_list_p (env
[i
] + len
))
1334 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1336 envlen
+= strlen (env
[i
]) + 1;
1340 if (conv_path_names
[j
] == NULL
)
1341 envlen
+= strlen (env
[i
]) + 1;
1344 winenv
= alloca (envlen
+ 1);
1346 /* Copy env strings into new buffer. */
1347 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1351 for (j
= 0; conv_path_names
[j
]; j
++)
1353 len
= strlen (conv_path_names
[j
]);
1354 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1356 if (cygwin_posix_path_list_p (env
[i
] + len
))
1358 memcpy (temp
, env
[i
], len
);
1359 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1362 strcpy (temp
, env
[i
]);
1366 if (conv_path_names
[j
] == NULL
)
1367 strcpy (temp
, env
[i
]);
1369 temp
+= strlen (temp
) + 1;
1372 /* Final nil string to terminate new env. */
1376 ret
= CreateProcess (0,
1377 args
, /* command line */
1378 NULL
, /* Security */
1380 TRUE
, /* inherit handles */
1381 flags
, /* start flags */
1383 NULL
, /* current directory */
1387 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1389 CloseHandle (pi
.hThread
);
1390 CloseHandle (pi
.hProcess
);
1391 do_initial_child_stuff (pi
.dwProcessId
);
1393 /* child_continue (DBG_CONTINUE, -1); */
1394 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1398 child_mourn_inferior (void)
1400 (void) child_continue (DBG_CONTINUE
, -1);
1401 i386_cleanup_dregs();
1402 unpush_target (&child_ops
);
1403 generic_mourn_inferior ();
1406 /* Send a SIGINT to the process group. This acts just like the user typed a
1407 ^C on the controlling terminal. */
1412 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1413 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1414 registers_changed (); /* refresh register state */
1418 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1419 int write
, struct mem_attrib
*mem
,
1420 struct target_ops
*target
)
1425 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1426 len
, (DWORD
) memaddr
));
1427 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1429 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1433 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1434 len
, (DWORD
) memaddr
));
1435 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1442 child_kill_inferior (void)
1444 CHECK (TerminateProcess (current_process_handle
, 0));
1448 if (!child_continue (DBG_CONTINUE
, -1))
1450 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1452 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1456 CHECK (CloseHandle (current_process_handle
));
1458 /* this may fail in an attached process so don't check. */
1459 (void) CloseHandle (current_thread
->h
);
1460 target_mourn_inferior (); /* or just child_mourn_inferior? */
1464 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1467 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1468 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1469 int pid
= PIDGET (ptid
);
1473 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1476 /* Get context for currently selected thread */
1477 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1482 /* Single step by setting t bit */
1483 child_fetch_inferior_registers (PS_REGNUM
);
1484 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1487 if (th
->context
.ContextFlags
)
1489 if (debug_registers_changed
)
1491 th
->context
.Dr0
= dr
[0];
1492 th
->context
.Dr1
= dr
[1];
1493 th
->context
.Dr2
= dr
[2];
1494 th
->context
.Dr3
= dr
[3];
1495 /* th->context.Dr6 = dr[6];
1496 FIXME: should we set dr6 also ?? */
1497 th
->context
.Dr7
= dr
[7];
1499 CHECK (SetThreadContext (th
->h
, &th
->context
));
1500 th
->context
.ContextFlags
= 0;
1504 /* Allow continuing with the same signal that interrupted us.
1505 Otherwise complain. */
1507 child_continue (continue_status
, pid
);
1511 child_prepare_to_store (void)
1513 /* Do nothing, since we can store individual regs */
1517 child_can_run (void)
1525 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1526 PIDGET (inferior_ptid
)));
1529 struct target_ops child_ops
;
1532 init_child_ops (void)
1534 child_ops
.to_shortname
= "child";
1535 child_ops
.to_longname
= "Win32 child process";
1536 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1537 child_ops
.to_open
= child_open
;
1538 child_ops
.to_close
= child_close
;
1539 child_ops
.to_attach
= child_attach
;
1540 child_ops
.to_detach
= child_detach
;
1541 child_ops
.to_resume
= child_resume
;
1542 child_ops
.to_wait
= child_wait
;
1543 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1544 child_ops
.to_store_registers
= child_store_inferior_registers
;
1545 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1546 child_ops
.to_xfer_memory
= child_xfer_memory
;
1547 child_ops
.to_files_info
= child_files_info
;
1548 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1549 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1550 child_ops
.to_terminal_init
= terminal_init_inferior
;
1551 child_ops
.to_terminal_inferior
= terminal_inferior
;
1552 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1553 child_ops
.to_terminal_ours
= terminal_ours
;
1554 child_ops
.to_terminal_info
= child_terminal_info
;
1555 child_ops
.to_kill
= child_kill_inferior
;
1556 child_ops
.to_load
= 0;
1557 child_ops
.to_lookup_symbol
= 0;
1558 child_ops
.to_create_inferior
= child_create_inferior
;
1559 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1560 child_ops
.to_can_run
= child_can_run
;
1561 child_ops
.to_notice_signals
= 0;
1562 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1563 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1564 child_ops
.to_stop
= child_stop
;
1565 child_ops
.to_stratum
= process_stratum
;
1566 child_ops
.DONT_USE
= 0;
1567 child_ops
.to_has_all_memory
= 1;
1568 child_ops
.to_has_memory
= 1;
1569 child_ops
.to_has_stack
= 1;
1570 child_ops
.to_has_registers
= 1;
1571 child_ops
.to_has_execution
= 1;
1572 child_ops
.to_sections
= 0;
1573 child_ops
.to_sections_end
= 0;
1574 child_ops
.to_magic
= OPS_MAGIC
;
1578 _initialize_inftarg (void)
1580 struct cmd_list_element
*c
;
1584 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1585 "Load dll library symbols from FILE.");
1586 c
->completer
= filename_completer
;
1588 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1590 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1591 (char *) &new_console
,
1592 "Set creation of new console when creating child process.",
1596 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1597 (char *) &new_group
,
1598 "Set creation of new group when creating child process.",
1602 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1603 (char *) &debug_exec
,
1604 "Set whether to display execution in child process.",
1608 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1609 (char *) &debug_events
,
1610 "Set whether to display kernel events in child process.",
1614 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1615 (char *) &debug_memory
,
1616 "Set whether to display memory accesses in child process.",
1620 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1621 (char *) &debug_exceptions
,
1622 "Set whether to display kernel exceptions in child process.",
1626 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1627 add_info_alias ("sharedlibrary", "dll", 1);
1629 add_target (&child_ops
);
1632 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1634 /* Pass the address ADDR to the inferior in the I'th debug register.
1635 Here we just store the address in dr array, the registers will be
1636 actually set up when child_continue is called. */
1638 cygwin_set_dr (int i
, CORE_ADDR addr
)
1641 internal_error (__FILE__
, __LINE__
,
1642 "Invalid register %d in cygwin_set_dr.\n", i
);
1643 dr
[i
] = (unsigned) addr
;
1644 debug_registers_changed
= 1;
1645 debug_registers_used
= 1;
1648 /* Pass the value VAL to the inferior in the DR7 debug control
1649 register. Here we just store the address in D_REGS, the watchpoint
1650 will be actually set up in child_wait. */
1652 cygwin_set_dr7 (unsigned val
)
1655 debug_registers_changed
= 1;
1656 debug_registers_used
= 1;
1659 /* Get the value of the DR6 debug status register from the inferior.
1660 Here we just return the value stored in dr[6]
1661 by the last call to thread_rec for current_event.dwThreadId id. */
1663 cygwin_get_dr6 (void)
1669 /* Determine if the thread referenced by "pid" is alive
1670 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1671 it means that the pid has died. Otherwise it is assumed to be alive. */
1673 win32_child_thread_alive (ptid_t ptid
)
1675 int pid
= PIDGET (ptid
);
1677 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1681 /* Convert pid to printable format. */
1683 cygwin_pid_to_str (ptid_t ptid
)
1685 static char buf
[80];
1686 int pid
= PIDGET (ptid
);
1688 if ((DWORD
) pid
== current_event
.dwProcessId
)
1689 sprintf (buf
, "process %d", pid
);
1691 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1696 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1698 struct objfile
*objfile
;
1699 char *objfile_basename
;
1700 const char *dll_basename
;
1702 if (!(dll_basename
= strrchr (dll_name
, '/')))
1703 dll_basename
= dll_name
;
1707 ALL_OBJFILES (objfile
)
1709 objfile_basename
= strrchr (objfile
->name
, '/');
1711 if (objfile_basename
&&
1712 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1714 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1715 base_addr
, dll_name
);
1720 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1721 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1729 struct target_ops
*target
;
1732 map_code_section_args
;
1735 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1739 struct section_table
*new_target_sect_ptr
;
1741 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1742 struct target_ops
*target
= args
->target
;
1743 if (sect
->flags
& SEC_CODE
)
1745 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1747 if (target
->to_sections
)
1749 old
= target
->to_sections_end
- target
->to_sections
;
1750 target
->to_sections
= (struct section_table
*)
1751 xrealloc ((char *) target
->to_sections
,
1752 (sizeof (struct section_table
)) * (1 + old
));
1757 target
->to_sections
= (struct section_table
*)
1758 xmalloc ((sizeof (struct section_table
)));
1760 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1762 /* Update the to_sections field in the core_ops structure
1766 core_ops
.to_sections
= target
->to_sections
;
1767 core_ops
.to_sections_end
= target
->to_sections_end
;
1769 new_target_sect_ptr
= target
->to_sections
+ old
;
1770 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1771 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1772 bfd_section_size (abfd
, sect
);;
1773 new_target_sect_ptr
->the_bfd_section
= sect
;
1774 new_target_sect_ptr
->bfd
= abfd
;
1779 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1782 map_code_section_args map_args
;
1783 asection
*lowest_sect
;
1785 if (dll_name
== NULL
|| target
== NULL
)
1787 name
= xstrdup (dll_name
);
1788 dll_bfd
= bfd_openr (name
, "pei-i386");
1789 if (dll_bfd
== NULL
)
1792 if (bfd_check_format (dll_bfd
, bfd_object
))
1794 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1795 if (lowest_sect
== NULL
)
1797 map_args
.target
= target
;
1798 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1800 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1807 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1809 struct target_ops
*target
= (struct target_ops
*) obj
;
1814 char *dll_name
= NULL
;
1816 struct win32_pstatus
*pstatus
;
1819 if (strncmp (sect
->name
, ".module", 7))
1822 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1825 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1828 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1831 pstatus
= (struct win32_pstatus
*) buf
;
1833 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1834 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1835 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1838 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1841 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1844 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1846 while ((p
= strchr (dll_name
, '\\')))
1849 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1850 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1852 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1853 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1864 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
1871 child_clear_solibs ();
1872 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1876 if (solib_end
&& solib_end
->name
)
1877 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
1878 solib_end
->load_addr
);
1883 fetch_elf_core_registers (char *core_reg_sect
,
1884 unsigned core_reg_size
,
1889 if (core_reg_size
< sizeof (CONTEXT
))
1891 error ("Core file register section too small (%u bytes).", core_reg_size
);
1894 for (r
= 0; r
< NUM_REGS
; r
++)
1895 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1898 static struct core_fns win32_elf_core_fns
=
1900 bfd_target_elf_flavour
,
1901 default_check_format
,
1902 default_core_sniffer
,
1903 fetch_elf_core_registers
,
1908 _initialize_core_win32 (void)
1910 add_core_fns (&win32_elf_core_fns
);
1914 _initialize_check_for_gdb_ini (void)
1917 if (inhibit_gdbinit
)
1920 homedir
= getenv ("HOME");
1924 char *oldini
= (char *) alloca (strlen (homedir
) +
1925 sizeof ("/gdb.ini"));
1926 strcpy (oldini
, homedir
);
1927 p
= strchr (oldini
, '\0');
1928 if (p
> oldini
&& p
[-1] != '/')
1930 strcpy (p
, "gdb.ini");
1931 if (access (oldini
, 0) == 0)
1933 int len
= strlen (oldini
);
1934 char *newini
= alloca (len
+ 1);
1935 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1936 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);