1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free
4 Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Originally by Steve Chamberlain, sac@cygnus.com */
27 /* We assume we're being built with and will be used for cygwin. */
30 #include "tm.h" /* required for SSE registers */
31 #include "frame.h" /* required by inferior.h */
36 #include "completer.h"
39 #include "i386-tdep.h"
41 #include <sys/types.h>
46 #include <sys/cygwin.h>
51 #include "gdb_string.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
57 /* The ui's event loop. */
58 extern int (*ui_loop_hook
) (int signo
);
60 /* If we're not using the old Cygwin header file set, define the
61 following which never should have been in the generic Win32 API
62 headers in the first place since they were our own invention... */
63 #ifndef _GNU_H_WINDOWS_H
66 FLAG_TRACE_BIT
= 0x100,
67 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
70 #include <sys/procfs.h>
74 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
75 | CONTEXT_EXTENDED_REGISTERS
77 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS
80 static unsigned dr
[8];
81 static int debug_registers_changed
= 0;
82 static int debug_registers_used
= 0;
84 /* The string sent by cygwin when it processes a signal.
85 FIXME: This should be in a cygwin include file. */
86 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
88 #define CHECK(x) check (x, __FILE__,__LINE__)
89 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
90 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
91 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
92 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
94 /* Forward declaration */
95 extern struct target_ops child_ops
;
97 static void child_stop (void);
98 static int win32_child_thread_alive (ptid_t
);
99 void child_kill_inferior (void);
101 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
102 /* Set if a signal was received from the debugged process */
104 /* Thread information structure used to track information that is
105 not available in gdb's thread structure. */
106 typedef struct thread_info_struct
108 struct thread_info_struct
*next
;
118 static thread_info thread_head
;
120 /* The process and thread handles for the above context. */
122 static DEBUG_EVENT current_event
; /* The current debug event from
124 static HANDLE current_process_handle
; /* Currently executing process */
125 static thread_info
*current_thread
; /* Info on currently selected thread */
126 static DWORD main_thread_id
; /* Thread ID of the main thread */
128 /* Counts of things. */
129 static int exception_count
= 0;
130 static int event_count
= 0;
131 static int saw_create
;
134 static int new_console
= 0;
135 static int new_group
= 1;
136 static int debug_exec
= 0; /* show execution */
137 static int debug_events
= 0; /* show events from kernel */
138 static int debug_memory
= 0; /* show target memory accesses */
139 static int debug_exceptions
= 0; /* show target exceptions */
140 static int useshell
= 0; /* use shell for subprocesses */
143 static char shell
[MAX_PATH
+ 1];
145 /* This vector maps GDB's idea of a register's number into an address
146 in the win32 exception context vector.
148 It also contains the bit mask needed to load the register in question.
150 One day we could read a reg, we could inspect the context we
151 already have loaded, if it doesn't have the bit set that we need,
152 we read that set of registers in using GetThreadContext. If the
153 context already contains what we need, we just unpack it. Then to
154 write a register, first we have to ensure that the context contains
155 the other regs of the group, and then we copy the info in and set
158 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
159 static const int mappings
[] =
161 context_offset (Eax
),
162 context_offset (Ecx
),
163 context_offset (Edx
),
164 context_offset (Ebx
),
165 context_offset (Esp
),
166 context_offset (Ebp
),
167 context_offset (Esi
),
168 context_offset (Edi
),
169 context_offset (Eip
),
170 context_offset (EFlags
),
171 context_offset (SegCs
),
172 context_offset (SegSs
),
173 context_offset (SegDs
),
174 context_offset (SegEs
),
175 context_offset (SegFs
),
176 context_offset (SegGs
),
177 context_offset (FloatSave
.RegisterArea
[0 * 10]),
178 context_offset (FloatSave
.RegisterArea
[1 * 10]),
179 context_offset (FloatSave
.RegisterArea
[2 * 10]),
180 context_offset (FloatSave
.RegisterArea
[3 * 10]),
181 context_offset (FloatSave
.RegisterArea
[4 * 10]),
182 context_offset (FloatSave
.RegisterArea
[5 * 10]),
183 context_offset (FloatSave
.RegisterArea
[6 * 10]),
184 context_offset (FloatSave
.RegisterArea
[7 * 10]),
185 context_offset (FloatSave
.ControlWord
),
186 context_offset (FloatSave
.StatusWord
),
187 context_offset (FloatSave
.TagWord
),
188 context_offset (FloatSave
.ErrorSelector
),
189 context_offset (FloatSave
.ErrorOffset
),
190 context_offset (FloatSave
.DataSelector
),
191 context_offset (FloatSave
.DataOffset
),
192 context_offset (FloatSave
.ErrorSelector
)
195 context_offset (ExtendedRegisters
[10*16]),
196 context_offset (ExtendedRegisters
[11*16]),
197 context_offset (ExtendedRegisters
[12*16]),
198 context_offset (ExtendedRegisters
[13*16]),
199 context_offset (ExtendedRegisters
[14*16]),
200 context_offset (ExtendedRegisters
[15*16]),
201 context_offset (ExtendedRegisters
[16*16]),
202 context_offset (ExtendedRegisters
[17*16]),
204 context_offset (ExtendedRegisters
[24])
208 #undef context_offset
210 /* This vector maps the target's idea of an exception (extracted
211 from the DEBUG_EVENT structure) to GDB's idea. */
213 struct xlate_exception
216 enum target_signal us
;
219 static const struct xlate_exception
222 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
223 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
224 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
225 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
226 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
227 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
231 check (BOOL ok
, const char *file
, int line
)
234 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
239 /* Find a thread record given a thread id.
240 If get_context then also retrieve the context for this
243 thread_rec (DWORD id
, int get_context
)
247 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
250 if (!th
->suspend_count
&& get_context
)
252 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
253 th
->suspend_count
= SuspendThread (th
->h
) + 1;
254 else if (get_context
< 0)
255 th
->suspend_count
= -1;
257 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
258 GetThreadContext (th
->h
, &th
->context
);
259 if (id
== current_event
.dwThreadId
)
261 /* Copy dr values from that thread. */
262 dr
[0] = th
->context
.Dr0
;
263 dr
[1] = th
->context
.Dr1
;
264 dr
[2] = th
->context
.Dr2
;
265 dr
[3] = th
->context
.Dr3
;
266 dr
[6] = th
->context
.Dr6
;
267 dr
[7] = th
->context
.Dr7
;
276 /* Add a thread to the thread list */
278 child_add_thread (DWORD id
, HANDLE h
)
282 if ((th
= thread_rec (id
, FALSE
)))
285 th
= (thread_info
*) xmalloc (sizeof (*th
));
286 memset (th
, 0, sizeof (*th
));
289 th
->next
= thread_head
.next
;
290 thread_head
.next
= th
;
291 add_thread (pid_to_ptid (id
));
292 /* Set the debug registers for the new thread in they are used. */
293 if (debug_registers_used
)
295 /* Only change the value of the debug registers. */
296 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
297 CHECK (GetThreadContext (th
->h
, &th
->context
));
298 th
->context
.Dr0
= dr
[0];
299 th
->context
.Dr1
= dr
[1];
300 th
->context
.Dr2
= dr
[2];
301 th
->context
.Dr3
= dr
[3];
302 /* th->context.Dr6 = dr[6];
303 FIXME: should we set dr6 also ?? */
304 th
->context
.Dr7
= dr
[7];
305 CHECK (SetThreadContext (th
->h
, &th
->context
));
306 th
->context
.ContextFlags
= 0;
311 /* Clear out any old thread list and reintialize it to a
314 child_init_thread_list (void)
316 thread_info
*th
= &thread_head
;
318 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
320 while (th
->next
!= NULL
)
322 thread_info
*here
= th
->next
;
323 th
->next
= here
->next
;
324 (void) CloseHandle (here
->h
);
329 /* Delete a thread from the list of threads */
331 child_delete_thread (DWORD id
)
336 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
337 delete_thread (pid_to_ptid (id
));
339 for (th
= &thread_head
;
340 th
->next
!= NULL
&& th
->next
->id
!= id
;
344 if (th
->next
!= NULL
)
346 thread_info
*here
= th
->next
;
347 th
->next
= here
->next
;
348 CloseHandle (here
->h
);
354 do_child_fetch_inferior_registers (int r
)
356 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
360 l
= *((long *) context_offset
) & 0xffff;
361 supply_register (r
, (char *) &l
);
363 else if (r
== FOP_REGNUM
)
365 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
366 supply_register (r
, (char *) &l
);
369 supply_register (r
, context_offset
);
372 for (r
= 0; r
< NUM_REGS
; r
++)
373 do_child_fetch_inferior_registers (r
);
378 child_fetch_inferior_registers (int r
)
380 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
381 do_child_fetch_inferior_registers (r
);
385 do_child_store_inferior_registers (int r
)
388 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
391 for (r
= 0; r
< NUM_REGS
; r
++)
392 do_child_store_inferior_registers (r
);
396 /* Store a new register value into the current thread context */
398 child_store_inferior_registers (int r
)
400 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
401 do_child_store_inferior_registers (r
);
404 static int psapi_loaded
= 0;
405 static HMODULE psapi_module_handle
= NULL
;
406 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
407 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
408 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
411 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
417 HMODULE
*DllHandle
= dh_buf
;
422 psapi_EnumProcessModules
== NULL
||
423 psapi_GetModuleInformation
== NULL
||
424 psapi_GetModuleFileNameExA
== NULL
)
429 psapi_module_handle
= LoadLibrary ("psapi.dll");
430 if (!psapi_module_handle
)
432 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
435 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
436 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
437 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
438 "GetModuleFileNameExA");
439 if (psapi_EnumProcessModules
== NULL
||
440 psapi_GetModuleInformation
== NULL
||
441 psapi_GetModuleFileNameExA
== NULL
)
446 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
451 if (!ok
|| !cbNeeded
)
454 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
458 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
465 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
467 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
471 error ("Can't get module info");
473 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
478 error ("Error getting dll name: %u\n", GetLastError ());
480 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
485 dll_name_ret
[0] = '\0';
489 /* Encapsulate the information required in a call to
490 symbol_file_add_args */
491 struct safe_symbol_file_add_args
495 struct section_addr_info
*addrs
;
498 struct ui_file
*err
, *out
;
502 /* Maintain a linked list of "so" information. */
505 struct so_stuff
*next
;
508 struct objfile
*objfile
;
510 } solib_start
, *solib_end
;
512 /* Call symbol_file_add with stderr redirected. We don't care if there
515 safe_symbol_file_add_stub (void *argv
)
517 #define p ((struct safe_symbol_file_add_args *)argv)
518 struct so_stuff
*so
= &solib_start
;
520 while ((so
= so
->next
))
521 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
523 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
528 /* Restore gdb's stderr after calling symbol_file_add */
530 safe_symbol_file_add_cleanup (void *p
)
532 #define sp ((struct safe_symbol_file_add_args *)p)
533 gdb_flush (gdb_stderr
);
534 gdb_flush (gdb_stdout
);
535 ui_file_delete (gdb_stderr
);
536 ui_file_delete (gdb_stdout
);
537 gdb_stderr
= sp
->err
;
538 gdb_stdout
= sp
->out
;
542 /* symbol_file_add wrapper that prevents errors from being displayed. */
543 static struct objfile
*
544 safe_symbol_file_add (char *name
, int from_tty
,
545 struct section_addr_info
*addrs
,
546 int mainline
, int flags
)
548 struct safe_symbol_file_add_args p
;
549 struct cleanup
*cleanup
;
551 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
555 gdb_flush (gdb_stderr
);
556 gdb_flush (gdb_stdout
);
557 gdb_stderr
= ui_file_new ();
558 gdb_stdout
= ui_file_new ();
560 p
.from_tty
= from_tty
;
562 p
.mainline
= mainline
;
564 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
566 do_cleanups (cleanup
);
570 /* Remember the maximum DLL length for printing in info dll command. */
571 int max_dll_name_len
;
574 register_loaded_dll (const char *name
, DWORD load_addr
)
577 char ppath
[MAX_PATH
+ 1];
578 char buf
[MAX_PATH
+ 1];
579 char cwd
[MAX_PATH
+ 1];
581 WIN32_FIND_DATA w32_fd
;
582 HANDLE h
= FindFirstFile(name
, &w32_fd
);
587 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
589 p
= strrchr (buf
, '\\');
592 SetCurrentDirectory (buf
);
593 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
594 SetCurrentDirectory (cwd
);
597 cygwin_conv_to_posix_path (buf
, ppath
);
598 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
600 so
->load_addr
= load_addr
;
603 strcpy (so
->name
, ppath
);
605 solib_end
->next
= so
;
607 len
= strlen (ppath
);
608 if (len
> max_dll_name_len
)
609 max_dll_name_len
= len
;
613 get_image_name (HANDLE h
, void *address
, int unicode
)
615 static char buf
[(2 * MAX_PATH
) + 1];
616 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
622 /* Attempt to read the name of the dll that was detected.
623 This is documented to work only when actively debugging
624 a program. It will not work for attached processes. */
628 ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
);
630 /* See if we could read the address of a string, and that the
631 address isn't null. */
633 if (done
!= sizeof (address_ptr
) || !address_ptr
)
636 /* Find the length of the string */
639 ReadProcessMemory (h
, address_ptr
+ len
* size
, &b
, size
, &done
);
642 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
645 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
648 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
649 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
652 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
658 /* Wait for child to do something. Return pid of child, or -1 in case
659 of error; store status through argument pointer OURSTATUS. */
661 handle_load_dll (void *dummy
)
663 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
664 char dll_buf
[MAX_PATH
+ 1];
665 char *dll_name
= NULL
;
668 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
670 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
671 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
675 if (*dll_name
== '\0')
676 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
680 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
686 handle_unload_dll (void *dummy
)
688 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
691 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
692 if (so
->next
->load_addr
== lpBaseOfDll
)
694 struct so_stuff
*sodel
= so
->next
;
695 so
->next
= sodel
->next
;
699 free_objfile (sodel
->objfile
);
703 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
708 /* Return name of last loaded DLL. */
710 child_solib_loaded_library_pathname (int pid
)
712 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
715 /* Clear list of loaded DLLs. */
717 child_clear_solibs (void)
719 struct so_stuff
*so
, *so1
= solib_start
.next
;
721 while ((so
= so1
) != NULL
)
727 solib_start
.next
= NULL
;
728 solib_start
.objfile
= NULL
;
729 solib_end
= &solib_start
;
730 max_dll_name_len
= sizeof ("DLL Name") - 1;
733 /* Add DLL symbol information. */
734 static struct objfile
*
735 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
737 struct section_addr_info section_addrs
;
739 /* The symbols in a dll are offset by 0x1000, which is the
740 the offset from 0 of the first byte in an image - because
741 of the file header and the section alignment. */
743 if (!name
|| !name
[0])
746 memset (§ion_addrs
, 0, sizeof (section_addrs
));
747 section_addrs
.other
[0].name
= ".text";
748 section_addrs
.other
[0].addr
= load_addr
;
749 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
752 /* Load DLL symbol info. */
754 dll_symbol_command (char *args
, int from_tty
)
760 error ("dll-symbols requires a file name");
763 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
765 char *newargs
= (char *) alloca (n
+ 4 + 1);
766 strcpy (newargs
, args
);
767 strcat (newargs
, ".dll");
771 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
774 /* List currently loaded DLLs. */
776 info_dll_command (char *ignore
, int from_tty
)
778 struct so_stuff
*so
= &solib_start
;
783 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
784 while ((so
= so
->next
) != NULL
)
785 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
790 /* Handle DEBUG_STRING output from child process.
791 Cygwin prepends its messages with a "cygwin:". Interpret this as
792 a Cygwin signal. Otherwise just print the string as a warning. */
794 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
799 if (!target_read_string
800 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
804 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
806 if (strncmp (s
, "cYg", 3) != 0)
812 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
813 gotasig
= target_signal_from_host (sig
);
814 ourstatus
->value
.sig
= gotasig
;
816 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
824 display_selector (HANDLE thread
, DWORD sel
)
827 if (GetThreadSelectorEntry (thread
, sel
, &info
))
830 printf_filtered ("0x%03lx: ", sel
);
831 if (!info
.HighWord
.Bits
.Pres
)
833 puts_filtered ("Segment not present\n");
836 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
837 (info
.HighWord
.Bits
.BaseMid
<< 16)
839 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
840 if (info
.HighWord
.Bits
.Granularity
)
841 limit
= (limit
<< 12) | 0xfff;
842 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
843 if (info
.HighWord
.Bits
.Default_Big
)
844 puts_filtered(" 32-bit ");
846 puts_filtered(" 16-bit ");
847 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
850 puts_filtered ("Data (Read-Only, Exp-up");
853 puts_filtered ("Data (Read/Write, Exp-up");
856 puts_filtered ("Unused segment (");
859 puts_filtered ("Data (Read/Write, Exp-down");
862 puts_filtered ("Code (Exec-Only, N.Conf");
865 puts_filtered ("Code (Exec/Read, N.Conf");
868 puts_filtered ("Code (Exec-Only, Conf");
871 puts_filtered ("Code (Exec/Read, Conf");
874 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
876 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
877 puts_filtered(", N.Acc");
878 puts_filtered (")\n");
879 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
880 puts_filtered("System selector ");
881 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
882 if (info
.HighWord
.Bits
.Granularity
)
883 puts_filtered ("Page granular.\n");
885 puts_filtered ("Byte granular.\n");
890 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
896 display_selectors (char * args
, int from_tty
)
900 puts_filtered ("Impossible to display selectors now.\n");
906 puts_filtered ("Selector $cs\n");
907 display_selector (current_thread
->h
,
908 current_thread
->context
.SegCs
);
909 puts_filtered ("Selector $ds\n");
910 display_selector (current_thread
->h
,
911 current_thread
->context
.SegDs
);
912 puts_filtered ("Selector $es\n");
913 display_selector (current_thread
->h
,
914 current_thread
->context
.SegEs
);
915 puts_filtered ("Selector $ss\n");
916 display_selector (current_thread
->h
,
917 current_thread
->context
.SegSs
);
918 puts_filtered ("Selector $fs\n");
919 display_selector (current_thread
->h
,
920 current_thread
->context
.SegFs
);
921 puts_filtered ("Selector $gs\n");
922 display_selector (current_thread
->h
,
923 current_thread
->context
.SegGs
);
928 sel
= parse_and_eval_long (args
);
929 printf_filtered ("Selector \"%s\"\n",args
);
930 display_selector (current_thread
->h
, sel
);
934 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
937 info_w32_command (char *args
, int from_tty
)
939 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
943 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
944 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
945 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
948 handle_exception (struct target_waitstatus
*ourstatus
)
951 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
953 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
955 /* Record the context of the current thread */
956 th
= thread_rec (current_event
.dwThreadId
, -1);
960 case EXCEPTION_ACCESS_VIOLATION
:
961 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
962 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
964 case STATUS_STACK_OVERFLOW
:
965 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
966 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
968 case STATUS_FLOAT_DENORMAL_OPERAND
:
969 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
970 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
972 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
973 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
974 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
976 case STATUS_FLOAT_INEXACT_RESULT
:
977 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
978 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
980 case STATUS_FLOAT_INVALID_OPERATION
:
981 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
982 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
984 case STATUS_FLOAT_OVERFLOW
:
985 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
986 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
988 case STATUS_FLOAT_STACK_CHECK
:
989 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
990 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
992 case STATUS_FLOAT_UNDERFLOW
:
993 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
994 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
996 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
997 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
998 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1000 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1001 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1002 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1004 case STATUS_INTEGER_OVERFLOW
:
1005 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1006 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1008 case EXCEPTION_BREAKPOINT
:
1009 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1010 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1013 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1014 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1016 case DBG_CONTROL_BREAK
:
1017 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1018 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1020 case EXCEPTION_SINGLE_STEP
:
1021 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1022 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1024 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1025 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1026 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1028 case EXCEPTION_PRIV_INSTRUCTION
:
1029 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1030 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1032 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1033 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1034 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1037 if (current_event
.u
.Exception
.dwFirstChance
)
1039 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1040 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1041 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1046 last_sig
= ourstatus
->value
.sig
;
1050 /* Resume all artificially suspended threads if we are continuing
1053 child_continue (DWORD continue_status
, int id
)
1059 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1060 current_event
.dwProcessId
, current_event
.dwThreadId
,
1061 continue_status
== DBG_CONTINUE
?
1062 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1063 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1064 current_event
.dwThreadId
,
1066 continue_status
= 0;
1068 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1069 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1072 for (i
= 0; i
< th
->suspend_count
; i
++)
1073 (void) ResumeThread (th
->h
);
1074 th
->suspend_count
= 0;
1075 if (debug_registers_changed
)
1077 /* Only change the value of the debug reisters */
1078 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1079 th
->context
.Dr0
= dr
[0];
1080 th
->context
.Dr1
= dr
[1];
1081 th
->context
.Dr2
= dr
[2];
1082 th
->context
.Dr3
= dr
[3];
1083 /* th->context.Dr6 = dr[6];
1084 FIXME: should we set dr6 also ?? */
1085 th
->context
.Dr7
= dr
[7];
1086 CHECK (SetThreadContext (th
->h
, &th
->context
));
1087 th
->context
.ContextFlags
= 0;
1091 debug_registers_changed
= 0;
1095 /* Get the next event from the child. Return 1 if the event requires
1096 handling by WFI (or whatever).
1099 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1102 DWORD continue_status
, event_code
;
1103 thread_info
*th
= NULL
;
1104 static thread_info dummy_thread_info
;
1107 last_sig
= TARGET_SIGNAL_0
;
1109 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1113 continue_status
= DBG_CONTINUE
;
1115 event_code
= current_event
.dwDebugEventCode
;
1116 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1120 case CREATE_THREAD_DEBUG_EVENT
:
1121 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1122 (unsigned) current_event
.dwProcessId
,
1123 (unsigned) current_event
.dwThreadId
,
1124 "CREATE_THREAD_DEBUG_EVENT"));
1125 if (saw_create
!= 1)
1127 /* Record the existence of this thread */
1128 th
= child_add_thread (current_event
.dwThreadId
,
1129 current_event
.u
.CreateThread
.hThread
);
1131 printf_unfiltered ("[New %s]\n",
1133 pid_to_ptid (current_event
.dwThreadId
)));
1134 retval
= current_event
.dwThreadId
;
1137 case EXIT_THREAD_DEBUG_EVENT
:
1138 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1139 (unsigned) current_event
.dwProcessId
,
1140 (unsigned) current_event
.dwThreadId
,
1141 "EXIT_THREAD_DEBUG_EVENT"));
1142 if (saw_create
!= 1)
1144 child_delete_thread (current_event
.dwThreadId
);
1145 th
= &dummy_thread_info
;
1148 case CREATE_PROCESS_DEBUG_EVENT
:
1149 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1150 (unsigned) current_event
.dwProcessId
,
1151 (unsigned) current_event
.dwThreadId
,
1152 "CREATE_PROCESS_DEBUG_EVENT"));
1153 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1154 if (++saw_create
!= 1)
1156 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1160 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1161 main_thread_id
= current_event
.dwThreadId
;
1162 /* Add the main thread */
1164 th
= child_add_thread (current_event
.dwProcessId
,
1165 current_event
.u
.CreateProcessInfo
.hProcess
);
1167 th
= child_add_thread (main_thread_id
,
1168 current_event
.u
.CreateProcessInfo
.hThread
);
1169 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1172 case EXIT_PROCESS_DEBUG_EVENT
:
1173 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1174 (unsigned) current_event
.dwProcessId
,
1175 (unsigned) current_event
.dwThreadId
,
1176 "EXIT_PROCESS_DEBUG_EVENT"));
1177 if (saw_create
!= 1)
1179 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1180 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1181 CloseHandle (current_process_handle
);
1182 retval
= main_thread_id
;
1185 case LOAD_DLL_DEBUG_EVENT
:
1186 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1187 (unsigned) current_event
.dwProcessId
,
1188 (unsigned) current_event
.dwThreadId
,
1189 "LOAD_DLL_DEBUG_EVENT"));
1190 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1191 if (saw_create
!= 1)
1193 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1194 registers_changed (); /* mark all regs invalid */
1195 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1196 ourstatus
->value
.integer
= 0;
1197 retval
= main_thread_id
;
1200 case UNLOAD_DLL_DEBUG_EVENT
:
1201 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1202 (unsigned) current_event
.dwProcessId
,
1203 (unsigned) current_event
.dwThreadId
,
1204 "UNLOAD_DLL_DEBUG_EVENT"));
1205 if (saw_create
!= 1)
1207 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1208 registers_changed (); /* mark all regs invalid */
1209 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1210 does not exist yet. */
1213 case EXCEPTION_DEBUG_EVENT
:
1214 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1215 (unsigned) current_event
.dwProcessId
,
1216 (unsigned) current_event
.dwThreadId
,
1217 "EXCEPTION_DEBUG_EVENT"));
1218 if (saw_create
!= 1)
1220 if (handle_exception (ourstatus
))
1221 retval
= current_event
.dwThreadId
;
1224 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1225 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1226 (unsigned) current_event
.dwProcessId
,
1227 (unsigned) current_event
.dwThreadId
,
1228 "OUTPUT_DEBUG_STRING_EVENT"));
1229 if (saw_create
!= 1)
1231 if (handle_output_debug_string (ourstatus
))
1232 retval
= main_thread_id
;
1236 if (saw_create
!= 1)
1238 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1239 (DWORD
) current_event
.dwProcessId
,
1240 (DWORD
) current_event
.dwThreadId
);
1241 printf_unfiltered (" unknown event code %ld\n",
1242 current_event
.dwDebugEventCode
);
1246 if (!retval
|| saw_create
!= 1)
1247 CHECK (child_continue (continue_status
, -1));
1250 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1251 inferior_ptid
= pid_to_ptid (retval
);
1258 /* Wait for interesting events to occur in the target process. */
1260 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1262 int pid
= PIDGET (ptid
);
1264 /* We loop when we get a non-standard exception rather than return
1265 with a SPURIOUS because resume can try and step or modify things,
1266 which needs a current_thread->h. But some of these exceptions mark
1267 the birth or death of threads, which mean that the current thread
1268 isn't necessarily what you think it is. */
1272 int retval
= get_child_debug_event (pid
, ourstatus
);
1274 return pid_to_ptid (retval
);
1279 if (ui_loop_hook
!= NULL
)
1280 detach
= ui_loop_hook (0);
1283 child_kill_inferior ();
1289 do_initial_child_stuff (DWORD pid
)
1291 extern int stop_after_trap
;
1294 last_sig
= TARGET_SIGNAL_0
;
1296 exception_count
= 0;
1297 debug_registers_changed
= 0;
1298 debug_registers_used
= 0;
1299 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1301 current_event
.dwProcessId
= pid
;
1302 memset (¤t_event
, 0, sizeof (current_event
));
1303 push_target (&child_ops
);
1304 child_init_thread_list ();
1305 child_clear_solibs ();
1306 clear_proceed_status ();
1307 init_wait_for_inferior ();
1309 target_terminal_init ();
1310 target_terminal_inferior ();
1314 stop_after_trap
= 1;
1315 wait_for_inferior ();
1316 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1317 resume (0, stop_signal
);
1321 stop_after_trap
= 0;
1325 /* Since Windows XP, detaching from a process is supported by Windows.
1326 The following code tries loading the appropriate functions dynamically.
1327 If loading these functions succeeds use them to actually detach from
1328 the inferior process, otherwise behave as usual, pretending that
1329 detach has worked. */
1330 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1331 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1334 has_detach_ability ()
1336 static HMODULE kernel32
= NULL
;
1339 kernel32
= LoadLibrary ("kernel32.dll");
1342 if (!DebugSetProcessKillOnExit
)
1343 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1344 "DebugSetProcessKillOnExit");
1345 if (!DebugActiveProcessStop
)
1346 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1347 "DebugActiveProcessStop");
1348 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1354 /* Attach to process PID, then initialize for debugging it. */
1356 child_attach (char *args
, int from_tty
)
1362 error_no_arg ("process-id to attach");
1364 pid
= strtoul (args
, 0, 0);
1365 ok
= DebugActiveProcess (pid
);
1368 error ("Can't attach to process.");
1370 if (has_detach_ability ())
1373 DebugSetProcessKillOnExit (FALSE
);
1378 char *exec_file
= (char *) get_exec_file (0);
1381 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1382 target_pid_to_str (pid_to_ptid (pid
)));
1384 printf_unfiltered ("Attaching to %s\n",
1385 target_pid_to_str (pid_to_ptid (pid
)));
1387 gdb_flush (gdb_stdout
);
1390 do_initial_child_stuff (pid
);
1391 target_terminal_ours ();
1395 child_detach (char *args
, int from_tty
)
1399 if (has_detach_ability ())
1401 delete_command (NULL
, 0);
1402 child_continue (DBG_CONTINUE
, -1);
1403 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1405 error ("Can't detach process %lu (error %lu)",
1406 current_event
.dwProcessId
, GetLastError ());
1409 DebugSetProcessKillOnExit (FALSE
);
1411 if (detached
&& from_tty
)
1413 char *exec_file
= get_exec_file (0);
1416 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1417 current_event
.dwProcessId
);
1418 gdb_flush (gdb_stdout
);
1420 inferior_ptid
= null_ptid
;
1421 unpush_target (&child_ops
);
1424 /* Print status information about what we're accessing. */
1427 child_files_info (struct target_ops
*ignore
)
1429 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1430 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1435 child_open (char *arg
, int from_tty
)
1437 error ("Use the \"run\" command to start a Unix child process.");
1440 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1441 EXEC_FILE is the file to run.
1442 ALLARGS is a string containing the arguments to the program.
1443 ENV is the environment vector to pass. Errors reported with error(). */
1446 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1453 PROCESS_INFORMATION pi
;
1457 char real_path
[MAXPATHLEN
];
1461 error ("No executable specified, use `target exec'.\n");
1463 memset (&si
, 0, sizeof (si
));
1464 si
.cb
= sizeof (si
);
1469 flags
|= CREATE_NEW_PROCESS_GROUP
;
1472 flags
|= CREATE_NEW_CONSOLE
;
1474 if (!useshell
|| !shell
[0])
1476 flags
= DEBUG_ONLY_THIS_PROCESS
;
1477 cygwin_conv_to_win32_path (exec_file
, real_path
);
1482 char *newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
) + strlen (allargs
) + 2);
1483 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1484 allargs
= newallargs
;
1486 flags
= DEBUG_PROCESS
;
1489 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1490 strcpy (args
, toexec
);
1492 strcat (args
, allargs
);
1494 /* Prepare the environment vars for CreateProcess. */
1496 /* This code use to assume all env vars were file names and would
1497 translate them all to win32 style. That obviously doesn't work in the
1498 general case. The current rule is that we only translate PATH.
1499 We need to handle PATH because we're about to call CreateProcess and
1500 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1501 in both posix and win32 environments. cygwin.dll will change it back
1502 to posix style if necessary. */
1504 static const char *conv_path_names
[] =
1510 /* CreateProcess takes the environment list as a null terminated set of
1511 strings (i.e. two nulls terminate the list). */
1513 /* Get total size for env strings. */
1514 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1518 for (j
= 0; conv_path_names
[j
]; j
++)
1520 len
= strlen (conv_path_names
[j
]);
1521 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1523 if (cygwin_posix_path_list_p (env
[i
] + len
))
1525 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1527 envlen
+= strlen (env
[i
]) + 1;
1531 if (conv_path_names
[j
] == NULL
)
1532 envlen
+= strlen (env
[i
]) + 1;
1535 winenv
= alloca (envlen
+ 1);
1537 /* Copy env strings into new buffer. */
1538 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1542 for (j
= 0; conv_path_names
[j
]; j
++)
1544 len
= strlen (conv_path_names
[j
]);
1545 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1547 if (cygwin_posix_path_list_p (env
[i
] + len
))
1549 memcpy (temp
, env
[i
], len
);
1550 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1553 strcpy (temp
, env
[i
]);
1557 if (conv_path_names
[j
] == NULL
)
1558 strcpy (temp
, env
[i
]);
1560 temp
+= strlen (temp
) + 1;
1563 /* Final nil string to terminate new env. */
1567 ret
= CreateProcess (0,
1568 args
, /* command line */
1569 NULL
, /* Security */
1571 TRUE
, /* inherit handles */
1572 flags
, /* start flags */
1574 NULL
, /* current directory */
1578 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1580 CloseHandle (pi
.hThread
);
1581 CloseHandle (pi
.hProcess
);
1583 if (useshell
&& shell
[0] != '\0')
1588 do_initial_child_stuff (pi
.dwProcessId
);
1590 /* child_continue (DBG_CONTINUE, -1); */
1591 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1595 child_mourn_inferior (void)
1597 (void) child_continue (DBG_CONTINUE
, -1);
1598 i386_cleanup_dregs();
1599 unpush_target (&child_ops
);
1600 generic_mourn_inferior ();
1603 /* Send a SIGINT to the process group. This acts just like the user typed a
1604 ^C on the controlling terminal. */
1609 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1610 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1611 registers_changed (); /* refresh register state */
1615 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1616 int write
, struct mem_attrib
*mem
,
1617 struct target_ops
*target
)
1622 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1623 len
, (DWORD
) memaddr
));
1624 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1626 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1630 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1631 len
, (DWORD
) memaddr
));
1632 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1639 child_kill_inferior (void)
1641 CHECK (TerminateProcess (current_process_handle
, 0));
1645 if (!child_continue (DBG_CONTINUE
, -1))
1647 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1649 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1653 CHECK (CloseHandle (current_process_handle
));
1655 /* this may fail in an attached process so don't check. */
1656 (void) CloseHandle (current_thread
->h
);
1657 target_mourn_inferior (); /* or just child_mourn_inferior? */
1661 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1664 DWORD continue_status
= DBG_CONTINUE
;
1666 int pid
= PIDGET (ptid
);
1668 if (sig
!= TARGET_SIGNAL_0
)
1670 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1672 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1674 else if (sig
== last_sig
)
1675 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1678 /* This code does not seem to work, because
1679 the kernel does probably not consider changes in the ExceptionRecord
1680 structure when passing the exception to the inferior.
1681 Note that this seems possible in the exception handler itself. */
1684 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1685 if (xlate
[i
].us
== sig
)
1687 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1689 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1692 if (continue_status
== DBG_CONTINUE
)
1694 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1698 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1702 last_sig
= TARGET_SIGNAL_0
;
1704 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1707 /* Get context for currently selected thread */
1708 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1713 /* Single step by setting t bit */
1714 child_fetch_inferior_registers (PS_REGNUM
);
1715 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1718 if (th
->context
.ContextFlags
)
1720 if (debug_registers_changed
)
1722 th
->context
.Dr0
= dr
[0];
1723 th
->context
.Dr1
= dr
[1];
1724 th
->context
.Dr2
= dr
[2];
1725 th
->context
.Dr3
= dr
[3];
1726 /* th->context.Dr6 = dr[6];
1727 FIXME: should we set dr6 also ?? */
1728 th
->context
.Dr7
= dr
[7];
1730 CHECK (SetThreadContext (th
->h
, &th
->context
));
1731 th
->context
.ContextFlags
= 0;
1735 /* Allow continuing with the same signal that interrupted us.
1736 Otherwise complain. */
1738 child_continue (continue_status
, pid
);
1742 child_prepare_to_store (void)
1744 /* Do nothing, since we can store individual regs */
1748 child_can_run (void)
1756 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1757 PIDGET (inferior_ptid
)));
1760 struct target_ops child_ops
;
1763 init_child_ops (void)
1765 child_ops
.to_shortname
= "child";
1766 child_ops
.to_longname
= "Win32 child process";
1767 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1768 child_ops
.to_open
= child_open
;
1769 child_ops
.to_close
= child_close
;
1770 child_ops
.to_attach
= child_attach
;
1771 child_ops
.to_detach
= child_detach
;
1772 child_ops
.to_resume
= child_resume
;
1773 child_ops
.to_wait
= child_wait
;
1774 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1775 child_ops
.to_store_registers
= child_store_inferior_registers
;
1776 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1777 child_ops
.to_xfer_memory
= child_xfer_memory
;
1778 child_ops
.to_files_info
= child_files_info
;
1779 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1780 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1781 child_ops
.to_terminal_init
= terminal_init_inferior
;
1782 child_ops
.to_terminal_inferior
= terminal_inferior
;
1783 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1784 child_ops
.to_terminal_ours
= terminal_ours
;
1785 child_ops
.to_terminal_info
= child_terminal_info
;
1786 child_ops
.to_kill
= child_kill_inferior
;
1787 child_ops
.to_load
= 0;
1788 child_ops
.to_lookup_symbol
= 0;
1789 child_ops
.to_create_inferior
= child_create_inferior
;
1790 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1791 child_ops
.to_can_run
= child_can_run
;
1792 child_ops
.to_notice_signals
= 0;
1793 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1794 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1795 child_ops
.to_stop
= child_stop
;
1796 child_ops
.to_stratum
= process_stratum
;
1797 child_ops
.DONT_USE
= 0;
1798 child_ops
.to_has_all_memory
= 1;
1799 child_ops
.to_has_memory
= 1;
1800 child_ops
.to_has_stack
= 1;
1801 child_ops
.to_has_registers
= 1;
1802 child_ops
.to_has_execution
= 1;
1803 child_ops
.to_sections
= 0;
1804 child_ops
.to_sections_end
= 0;
1805 child_ops
.to_magic
= OPS_MAGIC
;
1809 _initialize_inftarg (void)
1811 struct cmd_list_element
*c
;
1816 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1817 "Load dll library symbols from FILE.");
1818 c
->completer
= filename_completer
;
1820 sh
= getenv ("SHELL");
1823 if (access (sh
, X_OK
) != 0)
1830 cygwin_conv_to_win32_path (sh
, shell
);
1834 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1836 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
1838 "Set use of shell to start subprocess.",
1842 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1843 (char *) &new_console
,
1844 "Set creation of new console when creating child process.",
1848 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1849 (char *) &new_group
,
1850 "Set creation of new group when creating child process.",
1854 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1855 (char *) &debug_exec
,
1856 "Set whether to display execution in child process.",
1860 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1861 (char *) &debug_events
,
1862 "Set whether to display kernel events in child process.",
1866 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1867 (char *) &debug_memory
,
1868 "Set whether to display memory accesses in child process.",
1872 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1873 (char *) &debug_exceptions
,
1874 "Set whether to display kernel exceptions in child process.",
1878 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1879 add_info_alias ("sharedlibrary", "dll", 1);
1881 add_prefix_cmd ("w32", class_info
, info_w32_command
,
1882 "Print information specific to Win32 debugging.",
1883 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
1885 add_cmd ("selector", class_info
, display_selectors
,
1886 "Display selectors infos.",
1889 add_target (&child_ops
);
1892 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1894 /* Pass the address ADDR to the inferior in the I'th debug register.
1895 Here we just store the address in dr array, the registers will be
1896 actually set up when child_continue is called. */
1898 cygwin_set_dr (int i
, CORE_ADDR addr
)
1901 internal_error (__FILE__
, __LINE__
,
1902 "Invalid register %d in cygwin_set_dr.\n", i
);
1903 dr
[i
] = (unsigned) addr
;
1904 debug_registers_changed
= 1;
1905 debug_registers_used
= 1;
1908 /* Pass the value VAL to the inferior in the DR7 debug control
1909 register. Here we just store the address in D_REGS, the watchpoint
1910 will be actually set up in child_wait. */
1912 cygwin_set_dr7 (unsigned val
)
1915 debug_registers_changed
= 1;
1916 debug_registers_used
= 1;
1919 /* Get the value of the DR6 debug status register from the inferior.
1920 Here we just return the value stored in dr[6]
1921 by the last call to thread_rec for current_event.dwThreadId id. */
1923 cygwin_get_dr6 (void)
1929 /* Determine if the thread referenced by "pid" is alive
1930 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1931 it means that the pid has died. Otherwise it is assumed to be alive. */
1933 win32_child_thread_alive (ptid_t ptid
)
1935 int pid
= PIDGET (ptid
);
1937 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1941 /* Convert pid to printable format. */
1943 cygwin_pid_to_str (ptid_t ptid
)
1945 static char buf
[80];
1946 int pid
= PIDGET (ptid
);
1948 if ((DWORD
) pid
== current_event
.dwProcessId
)
1949 sprintf (buf
, "process %d", pid
);
1951 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1956 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1958 struct objfile
*objfile
;
1959 char *objfile_basename
;
1960 const char *dll_basename
;
1962 if (!(dll_basename
= strrchr (dll_name
, '/')))
1963 dll_basename
= dll_name
;
1967 ALL_OBJFILES (objfile
)
1969 objfile_basename
= strrchr (objfile
->name
, '/');
1971 if (objfile_basename
&&
1972 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1974 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1975 base_addr
, dll_name
);
1980 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1981 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1989 struct target_ops
*target
;
1992 map_code_section_args
;
1995 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1999 struct section_table
*new_target_sect_ptr
;
2001 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2002 struct target_ops
*target
= args
->target
;
2003 if (sect
->flags
& SEC_CODE
)
2005 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2007 if (target
->to_sections
)
2009 old
= target
->to_sections_end
- target
->to_sections
;
2010 target
->to_sections
= (struct section_table
*)
2011 xrealloc ((char *) target
->to_sections
,
2012 (sizeof (struct section_table
)) * (1 + old
));
2017 target
->to_sections
= (struct section_table
*)
2018 xmalloc ((sizeof (struct section_table
)));
2020 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2022 /* Update the to_sections field in the core_ops structure
2026 core_ops
.to_sections
= target
->to_sections
;
2027 core_ops
.to_sections_end
= target
->to_sections_end
;
2029 new_target_sect_ptr
= target
->to_sections
+ old
;
2030 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2031 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2032 bfd_section_size (abfd
, sect
);;
2033 new_target_sect_ptr
->the_bfd_section
= sect
;
2034 new_target_sect_ptr
->bfd
= abfd
;
2039 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2042 map_code_section_args map_args
;
2043 asection
*lowest_sect
;
2045 if (dll_name
== NULL
|| target
== NULL
)
2047 name
= xstrdup (dll_name
);
2048 dll_bfd
= bfd_openr (name
, "pei-i386");
2049 if (dll_bfd
== NULL
)
2052 if (bfd_check_format (dll_bfd
, bfd_object
))
2054 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2055 if (lowest_sect
== NULL
)
2057 map_args
.target
= target
;
2058 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2060 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2067 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2069 struct target_ops
*target
= (struct target_ops
*) obj
;
2074 char *dll_name
= NULL
;
2076 struct win32_pstatus
*pstatus
;
2079 if (strncmp (sect
->name
, ".module", 7))
2082 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2085 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2088 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2091 pstatus
= (struct win32_pstatus
*) buf
;
2093 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2094 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2095 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2098 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2101 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2104 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2106 while ((p
= strchr (dll_name
, '\\')))
2109 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2110 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2112 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2113 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2124 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2131 child_clear_solibs ();
2132 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2136 if (solib_end
&& solib_end
->name
)
2137 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2138 solib_end
->load_addr
);
2143 fetch_elf_core_registers (char *core_reg_sect
,
2144 unsigned core_reg_size
,
2149 if (core_reg_size
< sizeof (CONTEXT
))
2151 error ("Core file register section too small (%u bytes).", core_reg_size
);
2154 for (r
= 0; r
< NUM_REGS
; r
++)
2155 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2158 static struct core_fns win32_elf_core_fns
=
2160 bfd_target_elf_flavour
,
2161 default_check_format
,
2162 default_core_sniffer
,
2163 fetch_elf_core_registers
,
2168 _initialize_core_win32 (void)
2170 add_core_fns (&win32_elf_core_fns
);
2174 _initialize_check_for_gdb_ini (void)
2177 if (inhibit_gdbinit
)
2180 homedir
= getenv ("HOME");
2184 char *oldini
= (char *) alloca (strlen (homedir
) +
2185 sizeof ("/gdb.ini"));
2186 strcpy (oldini
, homedir
);
2187 p
= strchr (oldini
, '\0');
2188 if (p
> oldini
&& p
[-1] != '/')
2190 strcpy (p
, "gdb.ini");
2191 if (access (oldini
, 0) == 0)
2193 int len
= strlen (oldini
);
2194 char *newini
= alloca (len
+ 1);
2195 sprintf (newini
, "%.*s.gdbinit",
2196 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2197 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);