1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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 */
142 /* This vector maps GDB's idea of a register's number into an address
143 in the win32 exception context vector.
145 It also contains the bit mask needed to load the register in question.
147 One day we could read a reg, we could inspect the context we
148 already have loaded, if it doesn't have the bit set that we need,
149 we read that set of registers in using GetThreadContext. If the
150 context already contains what we need, we just unpack it. Then to
151 write a register, first we have to ensure that the context contains
152 the other regs of the group, and then we copy the info in and set
155 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
156 static const int mappings
[] =
158 context_offset (Eax
),
159 context_offset (Ecx
),
160 context_offset (Edx
),
161 context_offset (Ebx
),
162 context_offset (Esp
),
163 context_offset (Ebp
),
164 context_offset (Esi
),
165 context_offset (Edi
),
166 context_offset (Eip
),
167 context_offset (EFlags
),
168 context_offset (SegCs
),
169 context_offset (SegSs
),
170 context_offset (SegDs
),
171 context_offset (SegEs
),
172 context_offset (SegFs
),
173 context_offset (SegGs
),
174 context_offset (FloatSave
.RegisterArea
[0 * 10]),
175 context_offset (FloatSave
.RegisterArea
[1 * 10]),
176 context_offset (FloatSave
.RegisterArea
[2 * 10]),
177 context_offset (FloatSave
.RegisterArea
[3 * 10]),
178 context_offset (FloatSave
.RegisterArea
[4 * 10]),
179 context_offset (FloatSave
.RegisterArea
[5 * 10]),
180 context_offset (FloatSave
.RegisterArea
[6 * 10]),
181 context_offset (FloatSave
.RegisterArea
[7 * 10]),
182 context_offset (FloatSave
.ControlWord
),
183 context_offset (FloatSave
.StatusWord
),
184 context_offset (FloatSave
.TagWord
),
185 context_offset (FloatSave
.ErrorSelector
),
186 context_offset (FloatSave
.ErrorOffset
),
187 context_offset (FloatSave
.DataSelector
),
188 context_offset (FloatSave
.DataOffset
),
189 context_offset (FloatSave
.ErrorSelector
)
192 context_offset (ExtendedRegisters
[10*16]),
193 context_offset (ExtendedRegisters
[11*16]),
194 context_offset (ExtendedRegisters
[12*16]),
195 context_offset (ExtendedRegisters
[13*16]),
196 context_offset (ExtendedRegisters
[14*16]),
197 context_offset (ExtendedRegisters
[15*16]),
198 context_offset (ExtendedRegisters
[16*16]),
199 context_offset (ExtendedRegisters
[17*16]),
201 context_offset (ExtendedRegisters
[24])
205 #undef context_offset
207 /* This vector maps the target's idea of an exception (extracted
208 from the DEBUG_EVENT structure) to GDB's idea. */
210 struct xlate_exception
213 enum target_signal us
;
216 static const struct xlate_exception
219 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
220 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
221 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
222 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
223 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
224 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
228 check (BOOL ok
, const char *file
, int line
)
231 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
236 /* Find a thread record given a thread id.
237 If get_context then also retrieve the context for this
240 thread_rec (DWORD id
, int get_context
)
244 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
247 if (!th
->suspend_count
&& get_context
)
249 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
250 th
->suspend_count
= SuspendThread (th
->h
) + 1;
251 else if (get_context
< 0)
252 th
->suspend_count
= -1;
254 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
255 GetThreadContext (th
->h
, &th
->context
);
256 if (id
== current_event
.dwThreadId
)
258 /* Copy dr values from that thread. */
259 dr
[0] = th
->context
.Dr0
;
260 dr
[1] = th
->context
.Dr1
;
261 dr
[2] = th
->context
.Dr2
;
262 dr
[3] = th
->context
.Dr3
;
263 dr
[6] = th
->context
.Dr6
;
264 dr
[7] = th
->context
.Dr7
;
273 /* Add a thread to the thread list */
275 child_add_thread (DWORD id
, HANDLE h
)
279 if ((th
= thread_rec (id
, FALSE
)))
282 th
= (thread_info
*) xmalloc (sizeof (*th
));
283 memset (th
, 0, sizeof (*th
));
286 th
->next
= thread_head
.next
;
287 thread_head
.next
= th
;
288 add_thread (pid_to_ptid (id
));
289 /* Set the debug registers for the new thread in they are used. */
290 if (debug_registers_used
)
292 /* Only change the value of the debug registers. */
293 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
294 CHECK (GetThreadContext (th
->h
, &th
->context
));
295 th
->context
.Dr0
= dr
[0];
296 th
->context
.Dr1
= dr
[1];
297 th
->context
.Dr2
= dr
[2];
298 th
->context
.Dr3
= dr
[3];
299 /* th->context.Dr6 = dr[6];
300 FIXME: should we set dr6 also ?? */
301 th
->context
.Dr7
= dr
[7];
302 CHECK (SetThreadContext (th
->h
, &th
->context
));
303 th
->context
.ContextFlags
= 0;
308 /* Clear out any old thread list and reintialize it to a
311 child_init_thread_list (void)
313 thread_info
*th
= &thread_head
;
315 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
317 while (th
->next
!= NULL
)
319 thread_info
*here
= th
->next
;
320 th
->next
= here
->next
;
321 (void) CloseHandle (here
->h
);
326 /* Delete a thread from the list of threads */
328 child_delete_thread (DWORD id
)
333 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
334 delete_thread (pid_to_ptid (id
));
336 for (th
= &thread_head
;
337 th
->next
!= NULL
&& th
->next
->id
!= id
;
341 if (th
->next
!= NULL
)
343 thread_info
*here
= th
->next
;
344 th
->next
= here
->next
;
345 CloseHandle (here
->h
);
351 do_child_fetch_inferior_registers (int r
)
353 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
357 l
= *((long *) context_offset
) & 0xffff;
358 supply_register (r
, (char *) &l
);
360 else if (r
== FOP_REGNUM
)
362 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
363 supply_register (r
, (char *) &l
);
366 supply_register (r
, context_offset
);
369 for (r
= 0; r
< NUM_REGS
; r
++)
370 do_child_fetch_inferior_registers (r
);
375 child_fetch_inferior_registers (int r
)
377 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
378 do_child_fetch_inferior_registers (r
);
382 do_child_store_inferior_registers (int r
)
385 regcache_collect (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
388 for (r
= 0; r
< NUM_REGS
; r
++)
389 do_child_store_inferior_registers (r
);
393 /* Store a new register value into the current thread context */
395 child_store_inferior_registers (int r
)
397 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
398 do_child_store_inferior_registers (r
);
401 static int psapi_loaded
= 0;
402 static HMODULE psapi_module_handle
= NULL
;
403 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
404 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
405 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
408 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
414 HMODULE
*DllHandle
= dh_buf
;
419 psapi_EnumProcessModules
== NULL
||
420 psapi_GetModuleInformation
== NULL
||
421 psapi_GetModuleFileNameExA
== NULL
)
426 psapi_module_handle
= LoadLibrary ("psapi.dll");
427 if (!psapi_module_handle
)
429 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
432 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
433 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
434 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
435 "GetModuleFileNameExA");
436 if (psapi_EnumProcessModules
== NULL
||
437 psapi_GetModuleInformation
== NULL
||
438 psapi_GetModuleFileNameExA
== NULL
)
443 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
448 if (!ok
|| !cbNeeded
)
451 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
455 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
462 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
464 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
468 error ("Can't get module info");
470 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
475 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
477 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
482 dll_name_ret
[0] = '\0';
486 /* Encapsulate the information required in a call to
487 symbol_file_add_args */
488 struct safe_symbol_file_add_args
492 struct section_addr_info
*addrs
;
495 struct ui_file
*err
, *out
;
499 /* Maintain a linked list of "so" information. */
502 struct so_stuff
*next
;
506 struct objfile
*objfile
;
508 } solib_start
, *solib_end
;
510 /* Call symbol_file_add with stderr redirected. We don't care if there
513 safe_symbol_file_add_stub (void *argv
)
515 #define p ((struct safe_symbol_file_add_args *)argv)
516 struct so_stuff
*so
= &solib_start
;
518 while ((so
= so
->next
))
519 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
521 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
526 /* Restore gdb's stderr after calling symbol_file_add */
528 safe_symbol_file_add_cleanup (void *p
)
530 #define sp ((struct safe_symbol_file_add_args *)p)
531 gdb_flush (gdb_stderr
);
532 gdb_flush (gdb_stdout
);
533 ui_file_delete (gdb_stderr
);
534 ui_file_delete (gdb_stdout
);
535 gdb_stderr
= sp
->err
;
536 gdb_stdout
= sp
->out
;
540 /* symbol_file_add wrapper that prevents errors from being displayed. */
541 static struct objfile
*
542 safe_symbol_file_add (char *name
, int from_tty
,
543 struct section_addr_info
*addrs
,
544 int mainline
, int flags
)
546 struct safe_symbol_file_add_args p
;
547 struct cleanup
*cleanup
;
549 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
553 gdb_flush (gdb_stderr
);
554 gdb_flush (gdb_stdout
);
555 gdb_stderr
= ui_file_new ();
556 gdb_stdout
= ui_file_new ();
558 p
.from_tty
= from_tty
;
560 p
.mainline
= mainline
;
562 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
564 do_cleanups (cleanup
);
568 /* Remember the maximum DLL length for printing in info dll command. */
569 int max_dll_name_len
;
572 register_loaded_dll (const char *name
, DWORD load_addr
)
575 char ppath
[MAX_PATH
+ 1];
576 char buf
[MAX_PATH
+ 1];
577 char cwd
[MAX_PATH
+ 1];
579 WIN32_FIND_DATA w32_fd
;
580 HANDLE h
= FindFirstFile(name
, &w32_fd
);
581 MEMORY_BASIC_INFORMATION m
;
584 if (h
== INVALID_HANDLE_VALUE
)
590 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
592 p
= strrchr (buf
, '\\');
595 SetCurrentDirectory (buf
);
596 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
597 SetCurrentDirectory (cwd
);
601 cygwin_conv_to_posix_path (buf
, ppath
);
602 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
604 so
->load_addr
= load_addr
;
605 if (!VirtualQueryEx (current_process_handle
, (void *) load_addr
, &m
,
607 so
->end_addr
= (DWORD
) m
.AllocationBase
+ m
.RegionSize
;
609 so
->end_addr
= load_addr
+ 0x2000; /* completely arbitrary */
613 strcpy (so
->name
, ppath
);
615 solib_end
->next
= so
;
617 len
= strlen (ppath
);
618 if (len
> max_dll_name_len
)
619 max_dll_name_len
= len
;
623 get_image_name (HANDLE h
, void *address
, int unicode
)
625 static char buf
[(2 * MAX_PATH
) + 1];
626 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
632 /* Attempt to read the name of the dll that was detected.
633 This is documented to work only when actively debugging
634 a program. It will not work for attached processes. */
638 ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
);
640 /* See if we could read the address of a string, and that the
641 address isn't null. */
643 if (done
!= sizeof (address_ptr
) || !address_ptr
)
646 /* Find the length of the string */
649 ReadProcessMemory (h
, address_ptr
+ len
* size
, &b
, size
, &done
);
652 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
655 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
658 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
659 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
662 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
668 /* Wait for child to do something. Return pid of child, or -1 in case
669 of error; store status through argument pointer OURSTATUS. */
671 handle_load_dll (void *dummy
)
673 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
674 char dll_buf
[MAX_PATH
+ 1];
675 char *dll_name
= NULL
;
678 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
680 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
681 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
685 if (*dll_name
== '\0')
686 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
690 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
696 handle_unload_dll (void *dummy
)
698 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
701 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
702 if (so
->next
->load_addr
== lpBaseOfDll
)
704 struct so_stuff
*sodel
= so
->next
;
705 so
->next
= sodel
->next
;
709 free_objfile (sodel
->objfile
);
713 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
719 solib_address (CORE_ADDR address
)
722 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
723 if (address
>= so
->load_addr
&& address
<= so
->end_addr
)
728 /* Return name of last loaded DLL. */
730 child_solib_loaded_library_pathname (int pid
)
732 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
735 /* Clear list of loaded DLLs. */
737 child_clear_solibs (void)
739 struct so_stuff
*so
, *so1
= solib_start
.next
;
741 while ((so
= so1
) != NULL
)
747 solib_start
.next
= NULL
;
748 solib_start
.objfile
= NULL
;
749 solib_end
= &solib_start
;
750 max_dll_name_len
= sizeof ("DLL Name") - 1;
753 /* Add DLL symbol information. */
754 static struct objfile
*
755 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
757 struct section_addr_info section_addrs
;
759 /* The symbols in a dll are offset by 0x1000, which is the
760 the offset from 0 of the first byte in an image - because
761 of the file header and the section alignment. */
763 if (!name
|| !name
[0])
766 memset (§ion_addrs
, 0, sizeof (section_addrs
));
767 section_addrs
.other
[0].name
= ".text";
768 section_addrs
.other
[0].addr
= load_addr
;
769 return safe_symbol_file_add (name
, from_tty
, §ion_addrs
, 0, OBJF_SHARED
);
772 /* Load DLL symbol info. */
774 dll_symbol_command (char *args
, int from_tty
)
780 error ("dll-symbols requires a file name");
783 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
785 char *newargs
= (char *) alloca (n
+ 4 + 1);
786 strcpy (newargs
, args
);
787 strcat (newargs
, ".dll");
791 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
794 /* List currently loaded DLLs. */
796 info_dll_command (char *ignore
, int from_tty
)
798 struct so_stuff
*so
= &solib_start
;
803 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
804 while ((so
= so
->next
) != NULL
)
805 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
810 /* Handle DEBUG_STRING output from child process.
811 Cygwin prepends its messages with a "cygwin:". Interpret this as
812 a Cygwin signal. Otherwise just print the string as a warning. */
814 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
819 if (!target_read_string
820 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
824 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
826 if (strncmp (s
, "cYg", 3) != 0)
832 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
833 gotasig
= target_signal_from_host (sig
);
834 ourstatus
->value
.sig
= gotasig
;
836 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
844 display_selector (HANDLE thread
, DWORD sel
)
847 if (GetThreadSelectorEntry (thread
, sel
, &info
))
850 printf_filtered ("0x%03lx: ", sel
);
851 if (!info
.HighWord
.Bits
.Pres
)
853 puts_filtered ("Segment not present\n");
856 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
857 (info
.HighWord
.Bits
.BaseMid
<< 16)
859 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
860 if (info
.HighWord
.Bits
.Granularity
)
861 limit
= (limit
<< 12) | 0xfff;
862 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
863 if (info
.HighWord
.Bits
.Default_Big
)
864 puts_filtered(" 32-bit ");
866 puts_filtered(" 16-bit ");
867 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
870 puts_filtered ("Data (Read-Only, Exp-up");
873 puts_filtered ("Data (Read/Write, Exp-up");
876 puts_filtered ("Unused segment (");
879 puts_filtered ("Data (Read/Write, Exp-down");
882 puts_filtered ("Code (Exec-Only, N.Conf");
885 puts_filtered ("Code (Exec/Read, N.Conf");
888 puts_filtered ("Code (Exec-Only, Conf");
891 puts_filtered ("Code (Exec/Read, Conf");
894 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
896 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
897 puts_filtered(", N.Acc");
898 puts_filtered (")\n");
899 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
900 puts_filtered("System selector ");
901 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
902 if (info
.HighWord
.Bits
.Granularity
)
903 puts_filtered ("Page granular.\n");
905 puts_filtered ("Byte granular.\n");
910 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
916 display_selectors (char * args
, int from_tty
)
920 puts_filtered ("Impossible to display selectors now.\n");
926 puts_filtered ("Selector $cs\n");
927 display_selector (current_thread
->h
,
928 current_thread
->context
.SegCs
);
929 puts_filtered ("Selector $ds\n");
930 display_selector (current_thread
->h
,
931 current_thread
->context
.SegDs
);
932 puts_filtered ("Selector $es\n");
933 display_selector (current_thread
->h
,
934 current_thread
->context
.SegEs
);
935 puts_filtered ("Selector $ss\n");
936 display_selector (current_thread
->h
,
937 current_thread
->context
.SegSs
);
938 puts_filtered ("Selector $fs\n");
939 display_selector (current_thread
->h
,
940 current_thread
->context
.SegFs
);
941 puts_filtered ("Selector $gs\n");
942 display_selector (current_thread
->h
,
943 current_thread
->context
.SegGs
);
948 sel
= parse_and_eval_long (args
);
949 printf_filtered ("Selector \"%s\"\n",args
);
950 display_selector (current_thread
->h
, sel
);
954 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
957 info_w32_command (char *args
, int from_tty
)
959 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
963 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
964 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
965 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
968 handle_exception (struct target_waitstatus
*ourstatus
)
971 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
973 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
975 /* Record the context of the current thread */
976 th
= thread_rec (current_event
.dwThreadId
, -1);
980 case EXCEPTION_ACCESS_VIOLATION
:
981 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
982 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
984 case STATUS_STACK_OVERFLOW
:
985 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
986 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
988 case STATUS_FLOAT_DENORMAL_OPERAND
:
989 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
990 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
992 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
993 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
994 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
996 case STATUS_FLOAT_INEXACT_RESULT
:
997 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
998 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1000 case STATUS_FLOAT_INVALID_OPERATION
:
1001 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1002 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1004 case STATUS_FLOAT_OVERFLOW
:
1005 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1006 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1008 case STATUS_FLOAT_STACK_CHECK
:
1009 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1010 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1012 case STATUS_FLOAT_UNDERFLOW
:
1013 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1014 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1016 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1017 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1018 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1020 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1021 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1022 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1024 case STATUS_INTEGER_OVERFLOW
:
1025 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1026 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1028 case EXCEPTION_BREAKPOINT
:
1029 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1030 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1033 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1034 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1036 case DBG_CONTROL_BREAK
:
1037 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1038 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1040 case EXCEPTION_SINGLE_STEP
:
1041 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1044 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1045 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1046 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1048 case EXCEPTION_PRIV_INSTRUCTION
:
1049 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1050 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1052 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1053 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1054 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1057 if (current_event
.u
.Exception
.dwFirstChance
)
1059 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1060 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1061 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1062 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1066 last_sig
= ourstatus
->value
.sig
;
1070 /* Resume all artificially suspended threads if we are continuing
1073 child_continue (DWORD continue_status
, int id
)
1079 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1080 current_event
.dwProcessId
, current_event
.dwThreadId
,
1081 continue_status
== DBG_CONTINUE
?
1082 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1083 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1084 current_event
.dwThreadId
,
1086 continue_status
= 0;
1088 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1089 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1092 for (i
= 0; i
< th
->suspend_count
; i
++)
1093 (void) ResumeThread (th
->h
);
1094 th
->suspend_count
= 0;
1095 if (debug_registers_changed
)
1097 /* Only change the value of the debug reisters */
1098 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1099 th
->context
.Dr0
= dr
[0];
1100 th
->context
.Dr1
= dr
[1];
1101 th
->context
.Dr2
= dr
[2];
1102 th
->context
.Dr3
= dr
[3];
1103 /* th->context.Dr6 = dr[6];
1104 FIXME: should we set dr6 also ?? */
1105 th
->context
.Dr7
= dr
[7];
1106 CHECK (SetThreadContext (th
->h
, &th
->context
));
1107 th
->context
.ContextFlags
= 0;
1111 debug_registers_changed
= 0;
1115 /* Get the next event from the child. Return 1 if the event requires
1116 handling by WFI (or whatever).
1119 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1122 DWORD continue_status
, event_code
;
1123 thread_info
*th
= NULL
;
1124 static thread_info dummy_thread_info
;
1127 last_sig
= TARGET_SIGNAL_0
;
1129 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1133 continue_status
= DBG_CONTINUE
;
1135 event_code
= current_event
.dwDebugEventCode
;
1136 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1140 case CREATE_THREAD_DEBUG_EVENT
:
1141 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1142 (unsigned) current_event
.dwProcessId
,
1143 (unsigned) current_event
.dwThreadId
,
1144 "CREATE_THREAD_DEBUG_EVENT"));
1145 if (saw_create
!= 1)
1147 /* Record the existence of this thread */
1148 th
= child_add_thread (current_event
.dwThreadId
,
1149 current_event
.u
.CreateThread
.hThread
);
1151 printf_unfiltered ("[New %s]\n",
1153 pid_to_ptid (current_event
.dwThreadId
)));
1154 retval
= current_event
.dwThreadId
;
1157 case EXIT_THREAD_DEBUG_EVENT
:
1158 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1159 (unsigned) current_event
.dwProcessId
,
1160 (unsigned) current_event
.dwThreadId
,
1161 "EXIT_THREAD_DEBUG_EVENT"));
1162 if (saw_create
!= 1)
1164 child_delete_thread (current_event
.dwThreadId
);
1165 th
= &dummy_thread_info
;
1168 case CREATE_PROCESS_DEBUG_EVENT
:
1169 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1170 (unsigned) current_event
.dwProcessId
,
1171 (unsigned) current_event
.dwThreadId
,
1172 "CREATE_PROCESS_DEBUG_EVENT"));
1173 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1174 if (++saw_create
!= 1)
1176 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1180 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1181 main_thread_id
= current_event
.dwThreadId
;
1182 /* Add the main thread */
1184 th
= child_add_thread (current_event
.dwProcessId
,
1185 current_event
.u
.CreateProcessInfo
.hProcess
);
1187 th
= child_add_thread (main_thread_id
,
1188 current_event
.u
.CreateProcessInfo
.hThread
);
1189 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1192 case EXIT_PROCESS_DEBUG_EVENT
:
1193 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1194 (unsigned) current_event
.dwProcessId
,
1195 (unsigned) current_event
.dwThreadId
,
1196 "EXIT_PROCESS_DEBUG_EVENT"));
1197 if (saw_create
!= 1)
1199 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1200 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1201 CloseHandle (current_process_handle
);
1202 retval
= main_thread_id
;
1205 case LOAD_DLL_DEBUG_EVENT
:
1206 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1207 (unsigned) current_event
.dwProcessId
,
1208 (unsigned) current_event
.dwThreadId
,
1209 "LOAD_DLL_DEBUG_EVENT"));
1210 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1211 if (saw_create
!= 1)
1213 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1214 registers_changed (); /* mark all regs invalid */
1215 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1216 ourstatus
->value
.integer
= 0;
1217 retval
= main_thread_id
;
1218 re_enable_breakpoints_in_shlibs ();
1221 case UNLOAD_DLL_DEBUG_EVENT
:
1222 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1223 (unsigned) current_event
.dwProcessId
,
1224 (unsigned) current_event
.dwThreadId
,
1225 "UNLOAD_DLL_DEBUG_EVENT"));
1226 if (saw_create
!= 1)
1228 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1229 registers_changed (); /* mark all regs invalid */
1230 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1231 does not exist yet. */
1234 case EXCEPTION_DEBUG_EVENT
:
1235 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1236 (unsigned) current_event
.dwProcessId
,
1237 (unsigned) current_event
.dwThreadId
,
1238 "EXCEPTION_DEBUG_EVENT"));
1239 if (saw_create
!= 1)
1241 if (handle_exception (ourstatus
))
1242 retval
= current_event
.dwThreadId
;
1245 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1246 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1247 (unsigned) current_event
.dwProcessId
,
1248 (unsigned) current_event
.dwThreadId
,
1249 "OUTPUT_DEBUG_STRING_EVENT"));
1250 if (saw_create
!= 1)
1252 if (handle_output_debug_string (ourstatus
))
1253 retval
= main_thread_id
;
1257 if (saw_create
!= 1)
1259 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1260 (DWORD
) current_event
.dwProcessId
,
1261 (DWORD
) current_event
.dwThreadId
);
1262 printf_unfiltered (" unknown event code %ld\n",
1263 current_event
.dwDebugEventCode
);
1267 if (!retval
|| saw_create
!= 1)
1268 CHECK (child_continue (continue_status
, -1));
1271 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1272 inferior_ptid
= pid_to_ptid (retval
);
1279 /* Wait for interesting events to occur in the target process. */
1281 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1283 int pid
= PIDGET (ptid
);
1285 /* We loop when we get a non-standard exception rather than return
1286 with a SPURIOUS because resume can try and step or modify things,
1287 which needs a current_thread->h. But some of these exceptions mark
1288 the birth or death of threads, which mean that the current thread
1289 isn't necessarily what you think it is. */
1293 int retval
= get_child_debug_event (pid
, ourstatus
);
1295 return pid_to_ptid (retval
);
1300 if (ui_loop_hook
!= NULL
)
1301 detach
= ui_loop_hook (0);
1304 child_kill_inferior ();
1310 do_initial_child_stuff (DWORD pid
)
1312 extern int stop_after_trap
;
1315 last_sig
= TARGET_SIGNAL_0
;
1317 exception_count
= 0;
1318 debug_registers_changed
= 0;
1319 debug_registers_used
= 0;
1320 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1322 current_event
.dwProcessId
= pid
;
1323 memset (¤t_event
, 0, sizeof (current_event
));
1324 push_target (&child_ops
);
1325 child_init_thread_list ();
1326 disable_breakpoints_in_shlibs (1);
1327 child_clear_solibs ();
1328 clear_proceed_status ();
1329 init_wait_for_inferior ();
1331 target_terminal_init ();
1332 target_terminal_inferior ();
1336 stop_after_trap
= 1;
1337 wait_for_inferior ();
1338 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1339 resume (0, stop_signal
);
1343 stop_after_trap
= 0;
1347 /* Since Windows XP, detaching from a process is supported by Windows.
1348 The following code tries loading the appropriate functions dynamically.
1349 If loading these functions succeeds use them to actually detach from
1350 the inferior process, otherwise behave as usual, pretending that
1351 detach has worked. */
1352 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1353 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1356 has_detach_ability (void)
1358 static HMODULE kernel32
= NULL
;
1361 kernel32
= LoadLibrary ("kernel32.dll");
1364 if (!DebugSetProcessKillOnExit
)
1365 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1366 "DebugSetProcessKillOnExit");
1367 if (!DebugActiveProcessStop
)
1368 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1369 "DebugActiveProcessStop");
1370 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1376 /* Try to set or remove a user privilege to the current process. Return -1
1377 if that fails, the previous setting of that privilege otherwise.
1379 This code is copied from the Cygwin source code and rearranged to allow
1380 dynamically loading of the needed symbols from advapi32 which is only
1381 available on NT/2K/XP. */
1383 set_process_privilege (const char *privilege
, BOOL enable
)
1385 static HMODULE advapi32
= NULL
;
1386 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1387 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1388 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1389 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1391 HANDLE token_hdl
= NULL
;
1393 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1397 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1402 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1404 if (!OpenProcessToken
)
1405 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1406 if (!LookupPrivilegeValue
)
1407 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1408 "LookupPrivilegeValueA");
1409 if (!AdjustTokenPrivileges
)
1410 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1411 "AdjustTokenPrivileges");
1412 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1419 if (!OpenProcessToken (GetCurrentProcess (),
1420 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1424 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1427 new_priv
.PrivilegeCount
= 1;
1428 new_priv
.Privileges
[0].Luid
= restore_priv
;
1429 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1431 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1432 sizeof orig_priv
, &orig_priv
, &size
))
1435 /* Disabled, otherwise every `attach' in an unprivileged user session
1436 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1438 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1439 be enabled. GetLastError () returns an correct error code, though. */
1440 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1444 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1448 CloseHandle (token_hdl
);
1453 /* Attach to process PID, then initialize for debugging it. */
1455 child_attach (char *args
, int from_tty
)
1461 error_no_arg ("process-id to attach");
1463 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1465 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1466 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1469 pid
= strtoul (args
, 0, 0); /* Windows pid */
1471 ok
= DebugActiveProcess (pid
);
1476 /* Try fall back to Cygwin pid */
1477 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1480 ok
= DebugActiveProcess (pid
);
1483 error ("Can't attach to process.");
1486 if (has_detach_ability ())
1489 DebugSetProcessKillOnExit (FALSE
);
1494 char *exec_file
= (char *) get_exec_file (0);
1497 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1498 target_pid_to_str (pid_to_ptid (pid
)));
1500 printf_unfiltered ("Attaching to %s\n",
1501 target_pid_to_str (pid_to_ptid (pid
)));
1503 gdb_flush (gdb_stdout
);
1506 do_initial_child_stuff (pid
);
1507 target_terminal_ours ();
1511 child_detach (char *args
, int from_tty
)
1515 if (has_detach_ability ())
1517 delete_command (NULL
, 0);
1518 child_continue (DBG_CONTINUE
, -1);
1519 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1521 error ("Can't detach process %lu (error %lu)",
1522 current_event
.dwProcessId
, GetLastError ());
1525 DebugSetProcessKillOnExit (FALSE
);
1527 if (detached
&& from_tty
)
1529 char *exec_file
= get_exec_file (0);
1532 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1533 current_event
.dwProcessId
);
1534 gdb_flush (gdb_stdout
);
1536 inferior_ptid
= null_ptid
;
1537 unpush_target (&child_ops
);
1540 /* Print status information about what we're accessing. */
1543 child_files_info (struct target_ops
*ignore
)
1545 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1546 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1551 child_open (char *arg
, int from_tty
)
1553 error ("Use the \"run\" command to start a Unix child process.");
1556 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1557 EXEC_FILE is the file to run.
1558 ALLARGS is a string containing the arguments to the program.
1559 ENV is the environment vector to pass. Errors reported with error(). */
1562 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1569 PROCESS_INFORMATION pi
;
1573 char real_path
[MAXPATHLEN
];
1575 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1578 int ostdin
, ostdout
, ostderr
;
1581 error ("No executable specified, use `target exec'.\n");
1583 memset (&si
, 0, sizeof (si
));
1584 si
.cb
= sizeof (si
);
1588 flags
= DEBUG_ONLY_THIS_PROCESS
;
1589 cygwin_conv_to_win32_path (exec_file
, real_path
);
1595 sh
= getenv ("SHELL");
1598 cygwin_conv_to_win32_path (sh
, shell
);
1599 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1600 + strlen (allargs
) + 2);
1601 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1602 allargs
= newallargs
;
1604 flags
= DEBUG_PROCESS
;
1608 flags
|= CREATE_NEW_PROCESS_GROUP
;
1611 flags
|= CREATE_NEW_CONSOLE
;
1613 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1614 strcpy (args
, toexec
);
1616 strcat (args
, allargs
);
1618 /* Prepare the environment vars for CreateProcess. */
1620 /* This code used to assume all env vars were file names and would
1621 translate them all to win32 style. That obviously doesn't work in the
1622 general case. The current rule is that we only translate PATH.
1623 We need to handle PATH because we're about to call CreateProcess and
1624 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1625 in both posix and win32 environments. cygwin.dll will change it back
1626 to posix style if necessary. */
1628 static const char *conv_path_names
[] =
1634 /* CreateProcess takes the environment list as a null terminated set of
1635 strings (i.e. two nulls terminate the list). */
1637 /* Get total size for env strings. */
1638 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1642 for (j
= 0; conv_path_names
[j
]; j
++)
1644 len
= strlen (conv_path_names
[j
]);
1645 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1647 if (cygwin_posix_path_list_p (env
[i
] + len
))
1649 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1651 envlen
+= strlen (env
[i
]) + 1;
1655 if (conv_path_names
[j
] == NULL
)
1656 envlen
+= strlen (env
[i
]) + 1;
1659 winenv
= alloca (envlen
+ 1);
1661 /* Copy env strings into new buffer. */
1662 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1666 for (j
= 0; conv_path_names
[j
]; j
++)
1668 len
= strlen (conv_path_names
[j
]);
1669 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1671 if (cygwin_posix_path_list_p (env
[i
] + len
))
1673 memcpy (temp
, env
[i
], len
);
1674 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1677 strcpy (temp
, env
[i
]);
1681 if (conv_path_names
[j
] == NULL
)
1682 strcpy (temp
, env
[i
]);
1684 temp
+= strlen (temp
) + 1;
1687 /* Final nil string to terminate new env. */
1691 if (!inferior_io_terminal
)
1692 tty
= ostdin
= ostdout
= ostderr
= -1;
1695 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1698 print_sys_errmsg (inferior_io_terminal
, errno
);
1699 ostdin
= ostdout
= ostderr
= -1;
1712 ret
= CreateProcess (0,
1713 args
, /* command line */
1714 NULL
, /* Security */
1716 TRUE
, /* inherit handles */
1717 flags
, /* start flags */
1719 NULL
, /* current directory */
1734 error ("Error creating process %s, (error %d)\n", exec_file
, (unsigned) GetLastError ());
1736 CloseHandle (pi
.hThread
);
1737 CloseHandle (pi
.hProcess
);
1739 if (useshell
&& shell
[0] != '\0')
1744 do_initial_child_stuff (pi
.dwProcessId
);
1746 /* child_continue (DBG_CONTINUE, -1); */
1747 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1751 child_mourn_inferior (void)
1753 (void) child_continue (DBG_CONTINUE
, -1);
1754 i386_cleanup_dregs();
1755 unpush_target (&child_ops
);
1756 generic_mourn_inferior ();
1759 /* Send a SIGINT to the process group. This acts just like the user typed a
1760 ^C on the controlling terminal. */
1765 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1766 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1767 registers_changed (); /* refresh register state */
1771 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1772 int write
, struct mem_attrib
*mem
,
1773 struct target_ops
*target
)
1778 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1779 len
, (DWORD
) memaddr
));
1780 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1782 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1786 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1787 len
, (DWORD
) memaddr
));
1788 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1795 child_kill_inferior (void)
1797 CHECK (TerminateProcess (current_process_handle
, 0));
1801 if (!child_continue (DBG_CONTINUE
, -1))
1803 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1805 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1809 CHECK (CloseHandle (current_process_handle
));
1811 /* this may fail in an attached process so don't check. */
1812 (void) CloseHandle (current_thread
->h
);
1813 target_mourn_inferior (); /* or just child_mourn_inferior? */
1817 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1820 DWORD continue_status
= DBG_CONTINUE
;
1822 int pid
= PIDGET (ptid
);
1824 if (sig
!= TARGET_SIGNAL_0
)
1826 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1828 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1830 else if (sig
== last_sig
)
1831 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1834 /* This code does not seem to work, because
1835 the kernel does probably not consider changes in the ExceptionRecord
1836 structure when passing the exception to the inferior.
1837 Note that this seems possible in the exception handler itself. */
1840 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1841 if (xlate
[i
].us
== sig
)
1843 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1845 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1848 if (continue_status
== DBG_CONTINUE
)
1850 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1854 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1858 last_sig
= TARGET_SIGNAL_0
;
1860 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1863 /* Get context for currently selected thread */
1864 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1869 /* Single step by setting t bit */
1870 child_fetch_inferior_registers (PS_REGNUM
);
1871 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1874 if (th
->context
.ContextFlags
)
1876 if (debug_registers_changed
)
1878 th
->context
.Dr0
= dr
[0];
1879 th
->context
.Dr1
= dr
[1];
1880 th
->context
.Dr2
= dr
[2];
1881 th
->context
.Dr3
= dr
[3];
1882 /* th->context.Dr6 = dr[6];
1883 FIXME: should we set dr6 also ?? */
1884 th
->context
.Dr7
= dr
[7];
1886 CHECK (SetThreadContext (th
->h
, &th
->context
));
1887 th
->context
.ContextFlags
= 0;
1891 /* Allow continuing with the same signal that interrupted us.
1892 Otherwise complain. */
1894 child_continue (continue_status
, pid
);
1898 child_prepare_to_store (void)
1900 /* Do nothing, since we can store individual regs */
1904 child_can_run (void)
1912 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1913 PIDGET (inferior_ptid
)));
1916 struct target_ops child_ops
;
1919 init_child_ops (void)
1921 child_ops
.to_shortname
= "child";
1922 child_ops
.to_longname
= "Win32 child process";
1923 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1924 child_ops
.to_open
= child_open
;
1925 child_ops
.to_close
= child_close
;
1926 child_ops
.to_attach
= child_attach
;
1927 child_ops
.to_detach
= child_detach
;
1928 child_ops
.to_resume
= child_resume
;
1929 child_ops
.to_wait
= child_wait
;
1930 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1931 child_ops
.to_store_registers
= child_store_inferior_registers
;
1932 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1933 child_ops
.to_xfer_memory
= child_xfer_memory
;
1934 child_ops
.to_files_info
= child_files_info
;
1935 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1936 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1937 child_ops
.to_terminal_init
= terminal_init_inferior
;
1938 child_ops
.to_terminal_inferior
= terminal_inferior
;
1939 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1940 child_ops
.to_terminal_ours
= terminal_ours
;
1941 child_ops
.to_terminal_save_ours
= terminal_save_ours
;
1942 child_ops
.to_terminal_info
= child_terminal_info
;
1943 child_ops
.to_kill
= child_kill_inferior
;
1944 child_ops
.to_create_inferior
= child_create_inferior
;
1945 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1946 child_ops
.to_can_run
= child_can_run
;
1947 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1948 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1949 child_ops
.to_stop
= child_stop
;
1950 child_ops
.to_stratum
= process_stratum
;
1951 child_ops
.to_has_all_memory
= 1;
1952 child_ops
.to_has_memory
= 1;
1953 child_ops
.to_has_stack
= 1;
1954 child_ops
.to_has_registers
= 1;
1955 child_ops
.to_has_execution
= 1;
1956 child_ops
.to_magic
= OPS_MAGIC
;
1960 _initialize_win32_nat (void)
1962 struct cmd_list_element
*c
;
1966 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1967 "Load dll library symbols from FILE.");
1968 set_cmd_completer (c
, filename_completer
);
1970 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1972 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
1974 "Set use of shell to start subprocess.",
1978 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1979 (char *) &new_console
,
1980 "Set creation of new console when creating child process.",
1984 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1985 (char *) &new_group
,
1986 "Set creation of new group when creating child process.",
1990 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1991 (char *) &debug_exec
,
1992 "Set whether to display execution in child process.",
1996 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1997 (char *) &debug_events
,
1998 "Set whether to display kernel events in child process.",
2002 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
2003 (char *) &debug_memory
,
2004 "Set whether to display memory accesses in child process.",
2008 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
2009 (char *) &debug_exceptions
,
2010 "Set whether to display kernel exceptions in child process.",
2014 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
2015 add_info_alias ("sharedlibrary", "dll", 1);
2017 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2018 "Print information specific to Win32 debugging.",
2019 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2021 add_cmd ("selector", class_info
, display_selectors
,
2022 "Display selectors infos.",
2025 add_target (&child_ops
);
2028 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2030 /* Pass the address ADDR to the inferior in the I'th debug register.
2031 Here we just store the address in dr array, the registers will be
2032 actually set up when child_continue is called. */
2034 cygwin_set_dr (int i
, CORE_ADDR addr
)
2037 internal_error (__FILE__
, __LINE__
,
2038 "Invalid register %d in cygwin_set_dr.\n", i
);
2039 dr
[i
] = (unsigned) addr
;
2040 debug_registers_changed
= 1;
2041 debug_registers_used
= 1;
2044 /* Pass the value VAL to the inferior in the DR7 debug control
2045 register. Here we just store the address in D_REGS, the watchpoint
2046 will be actually set up in child_wait. */
2048 cygwin_set_dr7 (unsigned val
)
2051 debug_registers_changed
= 1;
2052 debug_registers_used
= 1;
2055 /* Get the value of the DR6 debug status register from the inferior.
2056 Here we just return the value stored in dr[6]
2057 by the last call to thread_rec for current_event.dwThreadId id. */
2059 cygwin_get_dr6 (void)
2065 /* Determine if the thread referenced by "pid" is alive
2066 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2067 it means that the pid has died. Otherwise it is assumed to be alive. */
2069 win32_child_thread_alive (ptid_t ptid
)
2071 int pid
= PIDGET (ptid
);
2073 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2077 /* Convert pid to printable format. */
2079 cygwin_pid_to_str (ptid_t ptid
)
2081 static char buf
[80];
2082 int pid
= PIDGET (ptid
);
2084 if ((DWORD
) pid
== current_event
.dwProcessId
)
2085 sprintf (buf
, "process %d", pid
);
2087 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2092 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
2094 struct objfile
*objfile
;
2095 char *objfile_basename
;
2096 const char *dll_basename
;
2098 if (!(dll_basename
= strrchr (dll_name
, '/')))
2099 dll_basename
= dll_name
;
2103 ALL_OBJFILES (objfile
)
2105 objfile_basename
= strrchr (objfile
->name
, '/');
2107 if (objfile_basename
&&
2108 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
2110 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2111 base_addr
, dll_name
);
2116 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
2117 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
2125 struct target_ops
*target
;
2128 map_code_section_args
;
2131 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2135 struct section_table
*new_target_sect_ptr
;
2137 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2138 struct target_ops
*target
= args
->target
;
2139 if (sect
->flags
& SEC_CODE
)
2141 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2143 if (target
->to_sections
)
2145 old
= target
->to_sections_end
- target
->to_sections
;
2146 target
->to_sections
= (struct section_table
*)
2147 xrealloc ((char *) target
->to_sections
,
2148 (sizeof (struct section_table
)) * (1 + old
));
2153 target
->to_sections
= (struct section_table
*)
2154 xmalloc ((sizeof (struct section_table
)));
2156 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2158 /* Update the to_sections field in the core_ops structure
2162 core_ops
.to_sections
= target
->to_sections
;
2163 core_ops
.to_sections_end
= target
->to_sections_end
;
2165 new_target_sect_ptr
= target
->to_sections
+ old
;
2166 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2167 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2168 bfd_section_size (abfd
, sect
);;
2169 new_target_sect_ptr
->the_bfd_section
= sect
;
2170 new_target_sect_ptr
->bfd
= abfd
;
2175 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2178 map_code_section_args map_args
;
2179 asection
*lowest_sect
;
2181 if (dll_name
== NULL
|| target
== NULL
)
2183 name
= xstrdup (dll_name
);
2184 dll_bfd
= bfd_openr (name
, "pei-i386");
2185 if (dll_bfd
== NULL
)
2188 if (bfd_check_format (dll_bfd
, bfd_object
))
2190 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2191 if (lowest_sect
== NULL
)
2193 map_args
.target
= target
;
2194 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2196 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2203 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2205 struct target_ops
*target
= (struct target_ops
*) obj
;
2210 char *dll_name
= NULL
;
2212 struct win32_pstatus
*pstatus
;
2215 if (strncmp (sect
->name
, ".module", 7))
2218 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2221 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2224 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2227 pstatus
= (struct win32_pstatus
*) buf
;
2229 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2230 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2231 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2234 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2237 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2240 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2242 while ((p
= strchr (dll_name
, '\\')))
2245 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2246 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2248 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2249 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2260 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2267 child_clear_solibs ();
2268 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2272 if (solib_end
&& solib_end
->name
)
2273 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2274 solib_end
->load_addr
);
2279 fetch_elf_core_registers (char *core_reg_sect
,
2280 unsigned core_reg_size
,
2285 if (core_reg_size
< sizeof (CONTEXT
))
2287 error ("Core file register section too small (%u bytes).", core_reg_size
);
2290 for (r
= 0; r
< NUM_REGS
; r
++)
2291 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2294 static struct core_fns win32_elf_core_fns
=
2296 bfd_target_elf_flavour
,
2297 default_check_format
,
2298 default_core_sniffer
,
2299 fetch_elf_core_registers
,
2304 _initialize_core_win32 (void)
2306 add_core_fns (&win32_elf_core_fns
);
2310 _initialize_check_for_gdb_ini (void)
2313 if (inhibit_gdbinit
)
2316 homedir
= getenv ("HOME");
2320 char *oldini
= (char *) alloca (strlen (homedir
) +
2321 sizeof ("/gdb.ini"));
2322 strcpy (oldini
, homedir
);
2323 p
= strchr (oldini
, '\0');
2324 if (p
> oldini
&& p
[-1] != '/')
2326 strcpy (p
, "gdb.ini");
2327 if (access (oldini
, 0) == 0)
2329 int len
= strlen (oldini
);
2330 char *newini
= alloca (len
+ 1);
2331 sprintf (newini
, "%.*s.gdbinit",
2332 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2333 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);