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 DBG_CONTROL_BREAK
:
871 DEBUG_EXCEPT (("gdb: Target exception CONTROL_BREAK at 0x%08lx\n",
872 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
873 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
874 last_sig
= SIGINT
; /* FIXME - should check pass state */
876 case EXCEPTION_SINGLE_STEP
:
877 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
878 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
879 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
881 case EXCEPTION_ILLEGAL_INSTRUCTION
:
882 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
883 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
884 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
888 if (current_event
.u
.Exception
.dwFirstChance
)
890 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
891 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
892 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
893 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
900 /* Resume all artificially suspended threads if we are continuing
903 child_continue (DWORD continue_status
, int id
)
909 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
910 current_event
.dwProcessId
, current_event
.dwThreadId
));
911 res
= ContinueDebugEvent (current_event
.dwProcessId
,
912 current_event
.dwThreadId
,
916 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
917 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
920 for (i
= 0; i
< th
->suspend_count
; i
++)
921 (void) ResumeThread (th
->h
);
922 th
->suspend_count
= 0;
923 if (debug_registers_changed
)
925 /* Only change the value of the debug reisters */
926 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
927 th
->context
.Dr0
= dr
[0];
928 th
->context
.Dr1
= dr
[1];
929 th
->context
.Dr2
= dr
[2];
930 th
->context
.Dr3
= dr
[3];
931 /* th->context.Dr6 = dr[6];
932 FIXME: should we set dr6 also ?? */
933 th
->context
.Dr7
= dr
[7];
934 CHECK (SetThreadContext (th
->h
, &th
->context
));
935 th
->context
.ContextFlags
= 0;
939 debug_registers_changed
= 0;
943 /* Get the next event from the child. Return 1 if the event requires
944 handling by WFI (or whatever).
947 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
950 DWORD continue_status
, event_code
;
951 thread_info
*th
= NULL
;
952 static thread_info dummy_thread_info
;
957 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
961 continue_status
= DBG_CONTINUE
;
963 event_code
= current_event
.dwDebugEventCode
;
964 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
968 case CREATE_THREAD_DEBUG_EVENT
:
969 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
970 (unsigned) current_event
.dwProcessId
,
971 (unsigned) current_event
.dwThreadId
,
972 "CREATE_THREAD_DEBUG_EVENT"));
973 /* Record the existence of this thread */
974 th
= child_add_thread (current_event
.dwThreadId
,
975 current_event
.u
.CreateThread
.hThread
);
977 printf_unfiltered ("[New %s]\n",
979 pid_to_ptid (current_event
.dwThreadId
)));
980 retval
= current_event
.dwThreadId
;
983 case EXIT_THREAD_DEBUG_EVENT
:
984 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
985 (unsigned) current_event
.dwProcessId
,
986 (unsigned) current_event
.dwThreadId
,
987 "EXIT_THREAD_DEBUG_EVENT"));
988 child_delete_thread (current_event
.dwThreadId
);
989 th
= &dummy_thread_info
;
992 case CREATE_PROCESS_DEBUG_EVENT
:
993 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
994 (unsigned) current_event
.dwProcessId
,
995 (unsigned) current_event
.dwThreadId
,
996 "CREATE_PROCESS_DEBUG_EVENT"));
997 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
998 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1000 main_thread_id
= current_event
.dwThreadId
;
1001 /* Add the main thread */
1003 th
= child_add_thread (current_event
.dwProcessId
,
1004 current_event
.u
.CreateProcessInfo
.hProcess
);
1006 th
= child_add_thread (main_thread_id
,
1007 current_event
.u
.CreateProcessInfo
.hThread
);
1008 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1011 case EXIT_PROCESS_DEBUG_EVENT
:
1012 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1013 (unsigned) current_event
.dwProcessId
,
1014 (unsigned) current_event
.dwThreadId
,
1015 "EXIT_PROCESS_DEBUG_EVENT"));
1016 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1017 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1018 CloseHandle (current_process_handle
);
1019 retval
= main_thread_id
;
1022 case LOAD_DLL_DEBUG_EVENT
:
1023 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1024 (unsigned) current_event
.dwProcessId
,
1025 (unsigned) current_event
.dwThreadId
,
1026 "LOAD_DLL_DEBUG_EVENT"));
1027 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1028 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1029 registers_changed (); /* mark all regs invalid */
1030 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1031 ourstatus
->value
.integer
= 0;
1032 retval
= main_thread_id
;
1035 case UNLOAD_DLL_DEBUG_EVENT
:
1036 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1037 (unsigned) current_event
.dwProcessId
,
1038 (unsigned) current_event
.dwThreadId
,
1039 "UNLOAD_DLL_DEBUG_EVENT"));
1040 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1041 registers_changed (); /* mark all regs invalid */
1042 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1043 does not exist yet. */
1046 case EXCEPTION_DEBUG_EVENT
:
1047 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1048 (unsigned) current_event
.dwProcessId
,
1049 (unsigned) current_event
.dwThreadId
,
1050 "EXCEPTION_DEBUG_EVENT"));
1051 if (handle_exception (ourstatus
))
1052 retval
= current_event
.dwThreadId
;
1055 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1056 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1057 (unsigned) current_event
.dwProcessId
,
1058 (unsigned) current_event
.dwThreadId
,
1059 "OUTPUT_DEBUG_STRING_EVENT"));
1060 if (handle_output_debug_string (ourstatus
))
1061 retval
= main_thread_id
;
1065 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1066 (DWORD
) current_event
.dwProcessId
,
1067 (DWORD
) current_event
.dwThreadId
);
1068 printf_unfiltered (" unknown event code %ld\n",
1069 current_event
.dwDebugEventCode
);
1074 CHECK (child_continue (continue_status
, -1));
1077 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1078 inferior_ptid
= pid_to_ptid (retval
);
1085 /* Wait for interesting events to occur in the target process. */
1087 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1089 int pid
= PIDGET (ptid
);
1091 /* We loop when we get a non-standard exception rather than return
1092 with a SPURIOUS because resume can try and step or modify things,
1093 which needs a current_thread->h. But some of these exceptions mark
1094 the birth or death of threads, which mean that the current thread
1095 isn't necessarily what you think it is. */
1099 int retval
= get_child_debug_event (pid
, ourstatus
);
1101 return pid_to_ptid (retval
);
1106 if (ui_loop_hook
!= NULL
)
1107 detach
= ui_loop_hook (0);
1110 child_kill_inferior ();
1116 do_initial_child_stuff (DWORD pid
)
1118 extern int stop_after_trap
;
1123 exception_count
= 0;
1124 debug_registers_changed
= 0;
1125 debug_registers_used
= 0;
1126 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1128 current_event
.dwProcessId
= pid
;
1129 memset (¤t_event
, 0, sizeof (current_event
));
1130 push_target (&child_ops
);
1131 child_init_thread_list ();
1132 child_clear_solibs ();
1133 clear_proceed_status ();
1134 init_wait_for_inferior ();
1136 target_terminal_init ();
1137 target_terminal_inferior ();
1141 stop_after_trap
= 1;
1142 wait_for_inferior ();
1143 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1144 resume (0, stop_signal
);
1148 stop_after_trap
= 0;
1152 /* Since Windows XP, detaching from a process is supported by Windows.
1153 The following code tries loading the appropriate functions dynamically.
1154 If loading these functions succeeds use them to actually detach from
1155 the inferior process, otherwise behave as usual, pretending that
1156 detach has worked. */
1157 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1158 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1161 has_detach_ability ()
1163 static HMODULE kernel32
= NULL
;
1166 kernel32
= LoadLibrary ("kernel32.dll");
1169 if (!DebugSetProcessKillOnExit
)
1170 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1171 "DebugSetProcessKillOnExit");
1172 if (!DebugActiveProcessStop
)
1173 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1174 "DebugActiveProcessStop");
1175 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1181 /* Attach to process PID, then initialize for debugging it. */
1183 child_attach (char *args
, int from_tty
)
1189 error_no_arg ("process-id to attach");
1191 pid
= strtoul (args
, 0, 0);
1192 ok
= DebugActiveProcess (pid
);
1195 error ("Can't attach to process.");
1197 if (has_detach_ability ())
1200 DebugSetProcessKillOnExit (FALSE
);
1205 char *exec_file
= (char *) get_exec_file (0);
1208 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1209 target_pid_to_str (pid_to_ptid (pid
)));
1211 printf_unfiltered ("Attaching to %s\n",
1212 target_pid_to_str (pid_to_ptid (pid
)));
1214 gdb_flush (gdb_stdout
);
1217 do_initial_child_stuff (pid
);
1218 target_terminal_ours ();
1222 child_detach (char *args
, int from_tty
)
1226 if (has_detach_ability ())
1228 delete_command (NULL
, 0);
1229 child_continue (DBG_CONTINUE
, -1);
1230 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1232 error ("Can't detach process %lu (error %lu)",
1233 current_event
.dwProcessId
, GetLastError ());
1236 DebugSetProcessKillOnExit (FALSE
);
1238 if (detached
&& from_tty
)
1240 char *exec_file
= get_exec_file (0);
1243 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1244 current_event
.dwProcessId
);
1245 gdb_flush (gdb_stdout
);
1247 inferior_ptid
= null_ptid
;
1248 unpush_target (&child_ops
);
1251 /* Print status information about what we're accessing. */
1254 child_files_info (struct target_ops
*ignore
)
1256 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1257 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1262 child_open (char *arg
, int from_tty
)
1264 error ("Use the \"run\" command to start a Unix child process.");
1267 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1268 EXEC_FILE is the file to run.
1269 ALLARGS is a string containing the arguments to the program.
1270 ENV is the environment vector to pass. Errors reported with error(). */
1273 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1275 char real_path
[MAXPATHLEN
];
1281 PROCESS_INFORMATION pi
;
1287 error ("No executable specified, use `target exec'.\n");
1289 memset (&si
, 0, sizeof (si
));
1290 si
.cb
= sizeof (si
);
1292 cygwin_conv_to_win32_path (exec_file
, real_path
);
1294 flags
= DEBUG_ONLY_THIS_PROCESS
;
1297 flags
|= CREATE_NEW_PROCESS_GROUP
;
1300 flags
|= CREATE_NEW_CONSOLE
;
1302 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1304 strcpy (args
, real_path
);
1307 strcat (args
, allargs
);
1309 /* Prepare the environment vars for CreateProcess. */
1311 /* This code use to assume all env vars were file names and would
1312 translate them all to win32 style. That obviously doesn't work in the
1313 general case. The current rule is that we only translate PATH.
1314 We need to handle PATH because we're about to call CreateProcess and
1315 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1316 in both posix and win32 environments. cygwin.dll will change it back
1317 to posix style if necessary. */
1319 static const char *conv_path_names
[] =
1325 /* CreateProcess takes the environment list as a null terminated set of
1326 strings (i.e. two nulls terminate the list). */
1328 /* Get total size for env strings. */
1329 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1333 for (j
= 0; conv_path_names
[j
]; j
++)
1335 len
= strlen (conv_path_names
[j
]);
1336 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1338 if (cygwin_posix_path_list_p (env
[i
] + len
))
1340 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1342 envlen
+= strlen (env
[i
]) + 1;
1346 if (conv_path_names
[j
] == NULL
)
1347 envlen
+= strlen (env
[i
]) + 1;
1350 winenv
= alloca (envlen
+ 1);
1352 /* Copy env strings into new buffer. */
1353 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1357 for (j
= 0; conv_path_names
[j
]; j
++)
1359 len
= strlen (conv_path_names
[j
]);
1360 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1362 if (cygwin_posix_path_list_p (env
[i
] + len
))
1364 memcpy (temp
, env
[i
], len
);
1365 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1368 strcpy (temp
, env
[i
]);
1372 if (conv_path_names
[j
] == NULL
)
1373 strcpy (temp
, env
[i
]);
1375 temp
+= strlen (temp
) + 1;
1378 /* Final nil string to terminate new env. */
1382 ret
= CreateProcess (0,
1383 args
, /* command line */
1384 NULL
, /* Security */
1386 TRUE
, /* inherit handles */
1387 flags
, /* start flags */
1389 NULL
, /* current directory */
1393 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1395 CloseHandle (pi
.hThread
);
1396 CloseHandle (pi
.hProcess
);
1397 do_initial_child_stuff (pi
.dwProcessId
);
1399 /* child_continue (DBG_CONTINUE, -1); */
1400 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1404 child_mourn_inferior (void)
1406 (void) child_continue (DBG_CONTINUE
, -1);
1407 i386_cleanup_dregs();
1408 unpush_target (&child_ops
);
1409 generic_mourn_inferior ();
1412 /* Send a SIGINT to the process group. This acts just like the user typed a
1413 ^C on the controlling terminal. */
1418 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1419 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1420 registers_changed (); /* refresh register state */
1424 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1425 int write
, struct mem_attrib
*mem
,
1426 struct target_ops
*target
)
1431 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1432 len
, (DWORD
) memaddr
));
1433 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1435 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1439 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1440 len
, (DWORD
) memaddr
));
1441 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1448 child_kill_inferior (void)
1450 CHECK (TerminateProcess (current_process_handle
, 0));
1454 if (!child_continue (DBG_CONTINUE
, -1))
1456 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1458 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1462 CHECK (CloseHandle (current_process_handle
));
1464 /* this may fail in an attached process so don't check. */
1465 (void) CloseHandle (current_thread
->h
);
1466 target_mourn_inferior (); /* or just child_mourn_inferior? */
1470 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1473 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1474 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1475 int pid
= PIDGET (ptid
);
1479 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1482 /* Get context for currently selected thread */
1483 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1488 /* Single step by setting t bit */
1489 child_fetch_inferior_registers (PS_REGNUM
);
1490 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1493 if (th
->context
.ContextFlags
)
1495 if (debug_registers_changed
)
1497 th
->context
.Dr0
= dr
[0];
1498 th
->context
.Dr1
= dr
[1];
1499 th
->context
.Dr2
= dr
[2];
1500 th
->context
.Dr3
= dr
[3];
1501 /* th->context.Dr6 = dr[6];
1502 FIXME: should we set dr6 also ?? */
1503 th
->context
.Dr7
= dr
[7];
1505 CHECK (SetThreadContext (th
->h
, &th
->context
));
1506 th
->context
.ContextFlags
= 0;
1510 /* Allow continuing with the same signal that interrupted us.
1511 Otherwise complain. */
1513 child_continue (continue_status
, pid
);
1517 child_prepare_to_store (void)
1519 /* Do nothing, since we can store individual regs */
1523 child_can_run (void)
1531 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1532 PIDGET (inferior_ptid
)));
1535 struct target_ops child_ops
;
1538 init_child_ops (void)
1540 child_ops
.to_shortname
= "child";
1541 child_ops
.to_longname
= "Win32 child process";
1542 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1543 child_ops
.to_open
= child_open
;
1544 child_ops
.to_close
= child_close
;
1545 child_ops
.to_attach
= child_attach
;
1546 child_ops
.to_detach
= child_detach
;
1547 child_ops
.to_resume
= child_resume
;
1548 child_ops
.to_wait
= child_wait
;
1549 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1550 child_ops
.to_store_registers
= child_store_inferior_registers
;
1551 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1552 child_ops
.to_xfer_memory
= child_xfer_memory
;
1553 child_ops
.to_files_info
= child_files_info
;
1554 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1555 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1556 child_ops
.to_terminal_init
= terminal_init_inferior
;
1557 child_ops
.to_terminal_inferior
= terminal_inferior
;
1558 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1559 child_ops
.to_terminal_ours
= terminal_ours
;
1560 child_ops
.to_terminal_info
= child_terminal_info
;
1561 child_ops
.to_kill
= child_kill_inferior
;
1562 child_ops
.to_load
= 0;
1563 child_ops
.to_lookup_symbol
= 0;
1564 child_ops
.to_create_inferior
= child_create_inferior
;
1565 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1566 child_ops
.to_can_run
= child_can_run
;
1567 child_ops
.to_notice_signals
= 0;
1568 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1569 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1570 child_ops
.to_stop
= child_stop
;
1571 child_ops
.to_stratum
= process_stratum
;
1572 child_ops
.DONT_USE
= 0;
1573 child_ops
.to_has_all_memory
= 1;
1574 child_ops
.to_has_memory
= 1;
1575 child_ops
.to_has_stack
= 1;
1576 child_ops
.to_has_registers
= 1;
1577 child_ops
.to_has_execution
= 1;
1578 child_ops
.to_sections
= 0;
1579 child_ops
.to_sections_end
= 0;
1580 child_ops
.to_magic
= OPS_MAGIC
;
1584 _initialize_inftarg (void)
1586 struct cmd_list_element
*c
;
1590 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1591 "Load dll library symbols from FILE.");
1592 c
->completer
= filename_completer
;
1594 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1596 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1597 (char *) &new_console
,
1598 "Set creation of new console when creating child process.",
1602 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1603 (char *) &new_group
,
1604 "Set creation of new group when creating child process.",
1608 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1609 (char *) &debug_exec
,
1610 "Set whether to display execution in child process.",
1614 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1615 (char *) &debug_events
,
1616 "Set whether to display kernel events in child process.",
1620 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1621 (char *) &debug_memory
,
1622 "Set whether to display memory accesses in child process.",
1626 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1627 (char *) &debug_exceptions
,
1628 "Set whether to display kernel exceptions in child process.",
1632 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1633 add_info_alias ("sharedlibrary", "dll", 1);
1635 add_target (&child_ops
);
1638 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1640 /* Pass the address ADDR to the inferior in the I'th debug register.
1641 Here we just store the address in dr array, the registers will be
1642 actually set up when child_continue is called. */
1644 cygwin_set_dr (int i
, CORE_ADDR addr
)
1647 internal_error (__FILE__
, __LINE__
,
1648 "Invalid register %d in cygwin_set_dr.\n", i
);
1649 dr
[i
] = (unsigned) addr
;
1650 debug_registers_changed
= 1;
1651 debug_registers_used
= 1;
1654 /* Pass the value VAL to the inferior in the DR7 debug control
1655 register. Here we just store the address in D_REGS, the watchpoint
1656 will be actually set up in child_wait. */
1658 cygwin_set_dr7 (unsigned val
)
1661 debug_registers_changed
= 1;
1662 debug_registers_used
= 1;
1665 /* Get the value of the DR6 debug status register from the inferior.
1666 Here we just return the value stored in dr[6]
1667 by the last call to thread_rec for current_event.dwThreadId id. */
1669 cygwin_get_dr6 (void)
1675 /* Determine if the thread referenced by "pid" is alive
1676 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1677 it means that the pid has died. Otherwise it is assumed to be alive. */
1679 win32_child_thread_alive (ptid_t ptid
)
1681 int pid
= PIDGET (ptid
);
1683 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1687 /* Convert pid to printable format. */
1689 cygwin_pid_to_str (ptid_t ptid
)
1691 static char buf
[80];
1692 int pid
= PIDGET (ptid
);
1694 if ((DWORD
) pid
== current_event
.dwProcessId
)
1695 sprintf (buf
, "process %d", pid
);
1697 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1702 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1704 struct objfile
*objfile
;
1705 char *objfile_basename
;
1706 const char *dll_basename
;
1708 if (!(dll_basename
= strrchr (dll_name
, '/')))
1709 dll_basename
= dll_name
;
1713 ALL_OBJFILES (objfile
)
1715 objfile_basename
= strrchr (objfile
->name
, '/');
1717 if (objfile_basename
&&
1718 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1720 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1721 base_addr
, dll_name
);
1726 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1727 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1735 struct target_ops
*target
;
1738 map_code_section_args
;
1741 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1745 struct section_table
*new_target_sect_ptr
;
1747 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1748 struct target_ops
*target
= args
->target
;
1749 if (sect
->flags
& SEC_CODE
)
1751 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1753 if (target
->to_sections
)
1755 old
= target
->to_sections_end
- target
->to_sections
;
1756 target
->to_sections
= (struct section_table
*)
1757 xrealloc ((char *) target
->to_sections
,
1758 (sizeof (struct section_table
)) * (1 + old
));
1763 target
->to_sections
= (struct section_table
*)
1764 xmalloc ((sizeof (struct section_table
)));
1766 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1768 /* Update the to_sections field in the core_ops structure
1772 core_ops
.to_sections
= target
->to_sections
;
1773 core_ops
.to_sections_end
= target
->to_sections_end
;
1775 new_target_sect_ptr
= target
->to_sections
+ old
;
1776 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1777 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1778 bfd_section_size (abfd
, sect
);;
1779 new_target_sect_ptr
->the_bfd_section
= sect
;
1780 new_target_sect_ptr
->bfd
= abfd
;
1785 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1788 map_code_section_args map_args
;
1789 asection
*lowest_sect
;
1791 if (dll_name
== NULL
|| target
== NULL
)
1793 name
= xstrdup (dll_name
);
1794 dll_bfd
= bfd_openr (name
, "pei-i386");
1795 if (dll_bfd
== NULL
)
1798 if (bfd_check_format (dll_bfd
, bfd_object
))
1800 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1801 if (lowest_sect
== NULL
)
1803 map_args
.target
= target
;
1804 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1806 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1813 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1815 struct target_ops
*target
= (struct target_ops
*) obj
;
1820 char *dll_name
= NULL
;
1822 struct win32_pstatus
*pstatus
;
1825 if (strncmp (sect
->name
, ".module", 7))
1828 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1831 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1834 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1837 pstatus
= (struct win32_pstatus
*) buf
;
1839 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1840 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1841 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1844 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1847 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1850 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1852 while ((p
= strchr (dll_name
, '\\')))
1855 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1856 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1858 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1859 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1870 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
1877 child_clear_solibs ();
1878 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1882 if (solib_end
&& solib_end
->name
)
1883 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
1884 solib_end
->load_addr
);
1889 fetch_elf_core_registers (char *core_reg_sect
,
1890 unsigned core_reg_size
,
1895 if (core_reg_size
< sizeof (CONTEXT
))
1897 error ("Core file register section too small (%u bytes).", core_reg_size
);
1900 for (r
= 0; r
< NUM_REGS
; r
++)
1901 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1904 static struct core_fns win32_elf_core_fns
=
1906 bfd_target_elf_flavour
,
1907 default_check_format
,
1908 default_core_sniffer
,
1909 fetch_elf_core_registers
,
1914 _initialize_core_win32 (void)
1916 add_core_fns (&win32_elf_core_fns
);
1920 _initialize_check_for_gdb_ini (void)
1923 if (inhibit_gdbinit
)
1926 homedir
= getenv ("HOME");
1930 char *oldini
= (char *) alloca (strlen (homedir
) +
1931 sizeof ("/gdb.ini"));
1932 strcpy (oldini
, homedir
);
1933 p
= strchr (oldini
, '\0');
1934 if (p
> oldini
&& p
[-1] != '/')
1936 strcpy (p
, "gdb.ini");
1937 if (access (oldini
, 0) == 0)
1939 int len
= strlen (oldini
);
1940 char *newini
= alloca (len
+ 1);
1941 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1942 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);