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 */
127 static pid_t cygwin_pid
; /* pid of cygwin process */
129 /* Counts of things. */
130 static int exception_count
= 0;
131 static int event_count
= 0;
132 static int saw_create
;
135 static int new_console
= 0;
136 static int new_group
= 1;
137 static int debug_exec
= 0; /* show execution */
138 static int debug_events
= 0; /* show events from kernel */
139 static int debug_memory
= 0; /* show target memory accesses */
140 static int debug_exceptions
= 0; /* show target exceptions */
141 static int useshell
= 0; /* use shell for subprocesses */
143 /* This vector maps GDB's idea of a register's number into an address
144 in the win32 exception context vector.
146 It also contains the bit mask needed to load the register in question.
148 One day we could read a reg, we could inspect the context we
149 already have loaded, if it doesn't have the bit set that we need,
150 we read that set of registers in using GetThreadContext. If the
151 context already contains what we need, we just unpack it. Then to
152 write a register, first we have to ensure that the context contains
153 the other regs of the group, and then we copy the info in and set
156 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
157 static const int mappings
[] =
159 context_offset (Eax
),
160 context_offset (Ecx
),
161 context_offset (Edx
),
162 context_offset (Ebx
),
163 context_offset (Esp
),
164 context_offset (Ebp
),
165 context_offset (Esi
),
166 context_offset (Edi
),
167 context_offset (Eip
),
168 context_offset (EFlags
),
169 context_offset (SegCs
),
170 context_offset (SegSs
),
171 context_offset (SegDs
),
172 context_offset (SegEs
),
173 context_offset (SegFs
),
174 context_offset (SegGs
),
175 context_offset (FloatSave
.RegisterArea
[0 * 10]),
176 context_offset (FloatSave
.RegisterArea
[1 * 10]),
177 context_offset (FloatSave
.RegisterArea
[2 * 10]),
178 context_offset (FloatSave
.RegisterArea
[3 * 10]),
179 context_offset (FloatSave
.RegisterArea
[4 * 10]),
180 context_offset (FloatSave
.RegisterArea
[5 * 10]),
181 context_offset (FloatSave
.RegisterArea
[6 * 10]),
182 context_offset (FloatSave
.RegisterArea
[7 * 10]),
183 context_offset (FloatSave
.ControlWord
),
184 context_offset (FloatSave
.StatusWord
),
185 context_offset (FloatSave
.TagWord
),
186 context_offset (FloatSave
.ErrorSelector
),
187 context_offset (FloatSave
.ErrorOffset
),
188 context_offset (FloatSave
.DataSelector
),
189 context_offset (FloatSave
.DataOffset
),
190 context_offset (FloatSave
.ErrorSelector
)
193 context_offset (ExtendedRegisters
[10*16]),
194 context_offset (ExtendedRegisters
[11*16]),
195 context_offset (ExtendedRegisters
[12*16]),
196 context_offset (ExtendedRegisters
[13*16]),
197 context_offset (ExtendedRegisters
[14*16]),
198 context_offset (ExtendedRegisters
[15*16]),
199 context_offset (ExtendedRegisters
[16*16]),
200 context_offset (ExtendedRegisters
[17*16]),
202 context_offset (ExtendedRegisters
[24])
206 #undef context_offset
208 /* This vector maps the target's idea of an exception (extracted
209 from the DEBUG_EVENT structure) to GDB's idea. */
211 struct xlate_exception
214 enum target_signal us
;
217 static const struct xlate_exception
220 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
221 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
222 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
223 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
224 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
225 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
229 check (BOOL ok
, const char *file
, int line
)
232 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
237 /* Find a thread record given a thread id.
238 If get_context then also retrieve the context for this
241 thread_rec (DWORD id
, int get_context
)
245 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
248 if (!th
->suspend_count
&& get_context
)
250 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
251 th
->suspend_count
= SuspendThread (th
->h
) + 1;
252 else if (get_context
< 0)
253 th
->suspend_count
= -1;
255 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
256 GetThreadContext (th
->h
, &th
->context
);
257 if (id
== current_event
.dwThreadId
)
259 /* Copy dr values from that thread. */
260 dr
[0] = th
->context
.Dr0
;
261 dr
[1] = th
->context
.Dr1
;
262 dr
[2] = th
->context
.Dr2
;
263 dr
[3] = th
->context
.Dr3
;
264 dr
[6] = th
->context
.Dr6
;
265 dr
[7] = th
->context
.Dr7
;
274 /* Add a thread to the thread list */
276 child_add_thread (DWORD id
, HANDLE h
)
280 if ((th
= thread_rec (id
, FALSE
)))
283 th
= (thread_info
*) xmalloc (sizeof (*th
));
284 memset (th
, 0, sizeof (*th
));
287 th
->next
= thread_head
.next
;
288 thread_head
.next
= th
;
289 add_thread (pid_to_ptid (id
));
290 /* Set the debug registers for the new thread in they are used. */
291 if (debug_registers_used
)
293 /* Only change the value of the debug registers. */
294 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
295 CHECK (GetThreadContext (th
->h
, &th
->context
));
296 th
->context
.Dr0
= dr
[0];
297 th
->context
.Dr1
= dr
[1];
298 th
->context
.Dr2
= dr
[2];
299 th
->context
.Dr3
= dr
[3];
300 /* th->context.Dr6 = dr[6];
301 FIXME: should we set dr6 also ?? */
302 th
->context
.Dr7
= dr
[7];
303 CHECK (SetThreadContext (th
->h
, &th
->context
));
304 th
->context
.ContextFlags
= 0;
309 /* Clear out any old thread list and reintialize it to a
312 child_init_thread_list (void)
314 thread_info
*th
= &thread_head
;
316 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
318 while (th
->next
!= NULL
)
320 thread_info
*here
= th
->next
;
321 th
->next
= here
->next
;
322 (void) CloseHandle (here
->h
);
327 /* Delete a thread from the list of threads */
329 child_delete_thread (DWORD id
)
334 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
335 delete_thread (pid_to_ptid (id
));
337 for (th
= &thread_head
;
338 th
->next
!= NULL
&& th
->next
->id
!= id
;
342 if (th
->next
!= NULL
)
344 thread_info
*here
= th
->next
;
345 th
->next
= here
->next
;
346 CloseHandle (here
->h
);
352 do_child_fetch_inferior_registers (int r
)
354 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
358 l
= *((long *) context_offset
) & 0xffff;
359 supply_register (r
, (char *) &l
);
361 else if (r
== FOP_REGNUM
)
363 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
364 supply_register (r
, (char *) &l
);
367 supply_register (r
, context_offset
);
370 for (r
= 0; r
< NUM_REGS
; r
++)
371 do_child_fetch_inferior_registers (r
);
376 child_fetch_inferior_registers (int r
)
378 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
379 do_child_fetch_inferior_registers (r
);
383 do_child_store_inferior_registers (int r
)
386 deprecated_read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
389 for (r
= 0; r
< NUM_REGS
; r
++)
390 do_child_store_inferior_registers (r
);
394 /* Store a new register value into the current thread context */
396 child_store_inferior_registers (int r
)
398 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
399 do_child_store_inferior_registers (r
);
402 static int psapi_loaded
= 0;
403 static HMODULE psapi_module_handle
= NULL
;
404 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
405 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
406 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
409 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
415 HMODULE
*DllHandle
= dh_buf
;
420 psapi_EnumProcessModules
== NULL
||
421 psapi_GetModuleInformation
== NULL
||
422 psapi_GetModuleFileNameExA
== NULL
)
427 psapi_module_handle
= LoadLibrary ("psapi.dll");
428 if (!psapi_module_handle
)
430 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
433 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
434 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
435 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
436 "GetModuleFileNameExA");
437 if (psapi_EnumProcessModules
== NULL
||
438 psapi_GetModuleInformation
== NULL
||
439 psapi_GetModuleFileNameExA
== NULL
)
444 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
449 if (!ok
|| !cbNeeded
)
452 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
456 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
463 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
465 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
469 error ("Can't get module info");
471 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
476 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
478 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
483 dll_name_ret
[0] = '\0';
487 /* Encapsulate the information required in a call to
488 symbol_file_add_args */
489 struct safe_symbol_file_add_args
493 struct section_addr_info
*addrs
;
496 struct ui_file
*err
, *out
;
500 /* Maintain a linked list of "so" information. */
503 struct so_stuff
*next
;
507 struct objfile
*objfile
;
509 } solib_start
, *solib_end
;
511 /* Call symbol_file_add with stderr redirected. We don't care if there
514 safe_symbol_file_add_stub (void *argv
)
516 #define p ((struct safe_symbol_file_add_args *)argv)
517 struct so_stuff
*so
= &solib_start
;
519 while ((so
= so
->next
))
520 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
522 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
527 /* Restore gdb's stderr after calling symbol_file_add */
529 safe_symbol_file_add_cleanup (void *p
)
531 #define sp ((struct safe_symbol_file_add_args *)p)
532 gdb_flush (gdb_stderr
);
533 gdb_flush (gdb_stdout
);
534 ui_file_delete (gdb_stderr
);
535 ui_file_delete (gdb_stdout
);
536 gdb_stderr
= sp
->err
;
537 gdb_stdout
= sp
->out
;
541 /* symbol_file_add wrapper that prevents errors from being displayed. */
542 static struct objfile
*
543 safe_symbol_file_add (char *name
, int from_tty
,
544 struct section_addr_info
*addrs
,
545 int mainline
, int flags
)
547 struct safe_symbol_file_add_args p
;
548 struct cleanup
*cleanup
;
550 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
554 gdb_flush (gdb_stderr
);
555 gdb_flush (gdb_stdout
);
556 gdb_stderr
= ui_file_new ();
557 gdb_stdout
= ui_file_new ();
559 p
.from_tty
= from_tty
;
561 p
.mainline
= mainline
;
563 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
565 do_cleanups (cleanup
);
569 /* Remember the maximum DLL length for printing in info dll command. */
570 int max_dll_name_len
;
573 register_loaded_dll (const char *name
, DWORD load_addr
)
576 char ppath
[MAX_PATH
+ 1];
577 char buf
[MAX_PATH
+ 1];
578 char cwd
[MAX_PATH
+ 1];
580 WIN32_FIND_DATA w32_fd
;
581 HANDLE h
= FindFirstFile(name
, &w32_fd
);
582 MEMORY_BASIC_INFORMATION m
;
585 if (h
== INVALID_HANDLE_VALUE
)
591 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
593 p
= strrchr (buf
, '\\');
596 SetCurrentDirectory (buf
);
597 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
598 SetCurrentDirectory (cwd
);
602 cygwin_conv_to_posix_path (buf
, ppath
);
603 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
605 so
->load_addr
= load_addr
;
606 if (!VirtualQueryEx (current_process_handle
, (void *) load_addr
, &m
,
608 so
->end_addr
= (DWORD
) m
.AllocationBase
+ m
.RegionSize
;
610 so
->end_addr
= load_addr
+ 0x2000; /* completely arbitrary */
614 strcpy (so
->name
, ppath
);
616 solib_end
->next
= so
;
618 len
= strlen (ppath
);
619 if (len
> max_dll_name_len
)
620 max_dll_name_len
= len
;
624 get_image_name (HANDLE h
, void *address
, int unicode
)
626 static char buf
[(2 * MAX_PATH
) + 1];
627 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
633 /* Attempt to read the name of the dll that was detected.
634 This is documented to work only when actively debugging
635 a program. It will not work for attached processes. */
639 ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
);
641 /* See if we could read the address of a string, and that the
642 address isn't null. */
644 if (done
!= sizeof (address_ptr
) || !address_ptr
)
647 /* Find the length of the string */
650 ReadProcessMemory (h
, address_ptr
+ len
* size
, &b
, size
, &done
);
653 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
656 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
659 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
660 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
663 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
669 /* Wait for child to do something. Return pid of child, or -1 in case
670 of error; store status through argument pointer OURSTATUS. */
672 handle_load_dll (void *dummy
)
674 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
675 char dll_buf
[MAX_PATH
+ 1];
676 char *dll_name
= NULL
;
679 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
681 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
682 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
686 if (*dll_name
== '\0')
687 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
691 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
697 handle_unload_dll (void *dummy
)
699 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
702 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
703 if (so
->next
->load_addr
== lpBaseOfDll
)
705 struct so_stuff
*sodel
= so
->next
;
706 so
->next
= sodel
->next
;
710 free_objfile (sodel
->objfile
);
714 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
720 solib_address (CORE_ADDR address
)
723 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
724 if (address
>= so
->load_addr
&& address
<= so
->end_addr
)
729 /* Return name of last loaded DLL. */
731 child_solib_loaded_library_pathname (int pid
)
733 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
736 /* Clear list of loaded DLLs. */
738 child_clear_solibs (void)
740 struct so_stuff
*so
, *so1
= solib_start
.next
;
742 while ((so
= so1
) != NULL
)
748 solib_start
.next
= NULL
;
749 solib_start
.objfile
= NULL
;
750 solib_end
= &solib_start
;
751 max_dll_name_len
= sizeof ("DLL Name") - 1;
754 /* Add DLL symbol information. */
755 static struct objfile
*
756 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
758 struct section_addr_info section_addrs
;
760 /* The symbols in a dll are offset by 0x1000, which is the
761 the offset from 0 of the first byte in an image - because
762 of the file header and the section alignment. */
764 if (!name
|| !name
[0])
767 memset (§ion_addrs
, 0, sizeof (section_addrs
));
768 section_addrs
.other
[0].name
= ".text";
769 section_addrs
.other
[0].addr
= load_addr
;
770 return safe_symbol_file_add (name
, from_tty
, §ion_addrs
, 0, OBJF_SHARED
);
773 /* Load DLL symbol info. */
775 dll_symbol_command (char *args
, int from_tty
)
781 error ("dll-symbols requires a file name");
784 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
786 char *newargs
= (char *) alloca (n
+ 4 + 1);
787 strcpy (newargs
, args
);
788 strcat (newargs
, ".dll");
792 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
795 /* List currently loaded DLLs. */
797 info_dll_command (char *ignore
, int from_tty
)
799 struct so_stuff
*so
= &solib_start
;
804 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
805 while ((so
= so
->next
) != NULL
)
806 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
811 /* Handle DEBUG_STRING output from child process.
812 Cygwin prepends its messages with a "cygwin:". Interpret this as
813 a Cygwin signal. Otherwise just print the string as a warning. */
815 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
820 if (!target_read_string
821 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
825 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
827 if (strncmp (s
, "cYg", 3) != 0)
833 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
834 gotasig
= target_signal_from_host (sig
);
835 ourstatus
->value
.sig
= gotasig
;
837 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
845 display_selector (HANDLE thread
, DWORD sel
)
848 if (GetThreadSelectorEntry (thread
, sel
, &info
))
851 printf_filtered ("0x%03lx: ", sel
);
852 if (!info
.HighWord
.Bits
.Pres
)
854 puts_filtered ("Segment not present\n");
857 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
858 (info
.HighWord
.Bits
.BaseMid
<< 16)
860 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
861 if (info
.HighWord
.Bits
.Granularity
)
862 limit
= (limit
<< 12) | 0xfff;
863 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
864 if (info
.HighWord
.Bits
.Default_Big
)
865 puts_filtered(" 32-bit ");
867 puts_filtered(" 16-bit ");
868 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
871 puts_filtered ("Data (Read-Only, Exp-up");
874 puts_filtered ("Data (Read/Write, Exp-up");
877 puts_filtered ("Unused segment (");
880 puts_filtered ("Data (Read/Write, Exp-down");
883 puts_filtered ("Code (Exec-Only, N.Conf");
886 puts_filtered ("Code (Exec/Read, N.Conf");
889 puts_filtered ("Code (Exec-Only, Conf");
892 puts_filtered ("Code (Exec/Read, Conf");
895 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
897 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
898 puts_filtered(", N.Acc");
899 puts_filtered (")\n");
900 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
901 puts_filtered("System selector ");
902 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
903 if (info
.HighWord
.Bits
.Granularity
)
904 puts_filtered ("Page granular.\n");
906 puts_filtered ("Byte granular.\n");
911 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
917 display_selectors (char * args
, int from_tty
)
921 puts_filtered ("Impossible to display selectors now.\n");
927 puts_filtered ("Selector $cs\n");
928 display_selector (current_thread
->h
,
929 current_thread
->context
.SegCs
);
930 puts_filtered ("Selector $ds\n");
931 display_selector (current_thread
->h
,
932 current_thread
->context
.SegDs
);
933 puts_filtered ("Selector $es\n");
934 display_selector (current_thread
->h
,
935 current_thread
->context
.SegEs
);
936 puts_filtered ("Selector $ss\n");
937 display_selector (current_thread
->h
,
938 current_thread
->context
.SegSs
);
939 puts_filtered ("Selector $fs\n");
940 display_selector (current_thread
->h
,
941 current_thread
->context
.SegFs
);
942 puts_filtered ("Selector $gs\n");
943 display_selector (current_thread
->h
,
944 current_thread
->context
.SegGs
);
949 sel
= parse_and_eval_long (args
);
950 printf_filtered ("Selector \"%s\"\n",args
);
951 display_selector (current_thread
->h
, sel
);
955 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
958 info_w32_command (char *args
, int from_tty
)
960 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
964 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
965 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
966 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
969 handle_exception (struct target_waitstatus
*ourstatus
)
972 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
974 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
976 /* Record the context of the current thread */
977 th
= thread_rec (current_event
.dwThreadId
, -1);
981 case EXCEPTION_ACCESS_VIOLATION
:
982 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
983 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
985 case STATUS_STACK_OVERFLOW
:
986 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
987 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
989 case STATUS_FLOAT_DENORMAL_OPERAND
:
990 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
991 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
993 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
994 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
995 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
997 case STATUS_FLOAT_INEXACT_RESULT
:
998 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
999 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1001 case STATUS_FLOAT_INVALID_OPERATION
:
1002 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1003 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1005 case STATUS_FLOAT_OVERFLOW
:
1006 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1007 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1009 case STATUS_FLOAT_STACK_CHECK
:
1010 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1011 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1013 case STATUS_FLOAT_UNDERFLOW
:
1014 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1015 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1017 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1018 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1019 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1021 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1022 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1023 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1025 case STATUS_INTEGER_OVERFLOW
:
1026 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1027 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1029 case EXCEPTION_BREAKPOINT
:
1030 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1031 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1034 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1035 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1037 case DBG_CONTROL_BREAK
:
1038 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1039 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1041 case EXCEPTION_SINGLE_STEP
:
1042 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1043 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1045 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1046 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1047 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1049 case EXCEPTION_PRIV_INSTRUCTION
:
1050 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1051 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1053 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1054 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1055 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1058 if (current_event
.u
.Exception
.dwFirstChance
)
1060 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1061 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1062 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1063 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1067 last_sig
= ourstatus
->value
.sig
;
1071 /* Resume all artificially suspended threads if we are continuing
1074 child_continue (DWORD continue_status
, int id
)
1080 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1081 current_event
.dwProcessId
, current_event
.dwThreadId
,
1082 continue_status
== DBG_CONTINUE
?
1083 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1084 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1085 current_event
.dwThreadId
,
1087 continue_status
= 0;
1089 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1090 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1093 for (i
= 0; i
< th
->suspend_count
; i
++)
1094 (void) ResumeThread (th
->h
);
1095 th
->suspend_count
= 0;
1096 if (debug_registers_changed
)
1098 /* Only change the value of the debug reisters */
1099 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1100 th
->context
.Dr0
= dr
[0];
1101 th
->context
.Dr1
= dr
[1];
1102 th
->context
.Dr2
= dr
[2];
1103 th
->context
.Dr3
= dr
[3];
1104 /* th->context.Dr6 = dr[6];
1105 FIXME: should we set dr6 also ?? */
1106 th
->context
.Dr7
= dr
[7];
1107 CHECK (SetThreadContext (th
->h
, &th
->context
));
1108 th
->context
.ContextFlags
= 0;
1112 debug_registers_changed
= 0;
1116 /* Get the next event from the child. Return 1 if the event requires
1117 handling by WFI (or whatever).
1120 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1123 DWORD continue_status
, event_code
;
1124 thread_info
*th
= NULL
;
1125 static thread_info dummy_thread_info
;
1128 last_sig
= TARGET_SIGNAL_0
;
1130 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1134 continue_status
= DBG_CONTINUE
;
1136 event_code
= current_event
.dwDebugEventCode
;
1137 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1141 case CREATE_THREAD_DEBUG_EVENT
:
1142 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1143 (unsigned) current_event
.dwProcessId
,
1144 (unsigned) current_event
.dwThreadId
,
1145 "CREATE_THREAD_DEBUG_EVENT"));
1146 if (saw_create
!= 1)
1148 /* Record the existence of this thread */
1149 th
= child_add_thread (current_event
.dwThreadId
,
1150 current_event
.u
.CreateThread
.hThread
);
1152 printf_unfiltered ("[New %s]\n",
1154 pid_to_ptid (current_event
.dwThreadId
)));
1155 retval
= current_event
.dwThreadId
;
1158 case EXIT_THREAD_DEBUG_EVENT
:
1159 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1160 (unsigned) current_event
.dwProcessId
,
1161 (unsigned) current_event
.dwThreadId
,
1162 "EXIT_THREAD_DEBUG_EVENT"));
1163 if (saw_create
!= 1)
1165 child_delete_thread (current_event
.dwThreadId
);
1166 th
= &dummy_thread_info
;
1169 case CREATE_PROCESS_DEBUG_EVENT
:
1170 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1171 (unsigned) current_event
.dwProcessId
,
1172 (unsigned) current_event
.dwThreadId
,
1173 "CREATE_PROCESS_DEBUG_EVENT"));
1174 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1175 if (++saw_create
!= 1)
1177 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1181 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1182 main_thread_id
= current_event
.dwThreadId
;
1183 /* Add the main thread */
1185 th
= child_add_thread (current_event
.dwProcessId
,
1186 current_event
.u
.CreateProcessInfo
.hProcess
);
1188 th
= child_add_thread (main_thread_id
,
1189 current_event
.u
.CreateProcessInfo
.hThread
);
1190 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1193 case EXIT_PROCESS_DEBUG_EVENT
:
1194 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1195 (unsigned) current_event
.dwProcessId
,
1196 (unsigned) current_event
.dwThreadId
,
1197 "EXIT_PROCESS_DEBUG_EVENT"));
1198 if (saw_create
!= 1)
1200 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1201 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1202 CloseHandle (current_process_handle
);
1203 retval
= main_thread_id
;
1206 case LOAD_DLL_DEBUG_EVENT
:
1207 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1208 (unsigned) current_event
.dwProcessId
,
1209 (unsigned) current_event
.dwThreadId
,
1210 "LOAD_DLL_DEBUG_EVENT"));
1211 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1212 if (saw_create
!= 1)
1214 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1215 registers_changed (); /* mark all regs invalid */
1216 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1217 ourstatus
->value
.integer
= 0;
1218 retval
= main_thread_id
;
1219 re_enable_breakpoints_in_shlibs ();
1222 case UNLOAD_DLL_DEBUG_EVENT
:
1223 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1224 (unsigned) current_event
.dwProcessId
,
1225 (unsigned) current_event
.dwThreadId
,
1226 "UNLOAD_DLL_DEBUG_EVENT"));
1227 if (saw_create
!= 1)
1229 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1230 registers_changed (); /* mark all regs invalid */
1231 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1232 does not exist yet. */
1235 case EXCEPTION_DEBUG_EVENT
:
1236 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1237 (unsigned) current_event
.dwProcessId
,
1238 (unsigned) current_event
.dwThreadId
,
1239 "EXCEPTION_DEBUG_EVENT"));
1240 if (saw_create
!= 1)
1242 if (handle_exception (ourstatus
))
1243 retval
= current_event
.dwThreadId
;
1246 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1247 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1248 (unsigned) current_event
.dwProcessId
,
1249 (unsigned) current_event
.dwThreadId
,
1250 "OUTPUT_DEBUG_STRING_EVENT"));
1251 if (saw_create
!= 1)
1253 if (handle_output_debug_string (ourstatus
))
1254 retval
= main_thread_id
;
1258 if (saw_create
!= 1)
1260 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1261 (DWORD
) current_event
.dwProcessId
,
1262 (DWORD
) current_event
.dwThreadId
);
1263 printf_unfiltered (" unknown event code %ld\n",
1264 current_event
.dwDebugEventCode
);
1268 if (!retval
|| saw_create
!= 1)
1269 CHECK (child_continue (continue_status
, -1));
1272 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1273 inferior_ptid
= pid_to_ptid (retval
);
1280 /* Wait for interesting events to occur in the target process. */
1282 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1284 int pid
= PIDGET (ptid
);
1286 /* We loop when we get a non-standard exception rather than return
1287 with a SPURIOUS because resume can try and step or modify things,
1288 which needs a current_thread->h. But some of these exceptions mark
1289 the birth or death of threads, which mean that the current thread
1290 isn't necessarily what you think it is. */
1294 int retval
= get_child_debug_event (pid
, ourstatus
);
1296 return pid_to_ptid (retval
);
1301 if (ui_loop_hook
!= NULL
)
1302 detach
= ui_loop_hook (0);
1305 child_kill_inferior ();
1311 do_initial_child_stuff (DWORD pid
)
1313 extern int stop_after_trap
;
1316 last_sig
= TARGET_SIGNAL_0
;
1318 exception_count
= 0;
1319 debug_registers_changed
= 0;
1320 debug_registers_used
= 0;
1321 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1323 current_event
.dwProcessId
= pid
;
1324 memset (¤t_event
, 0, sizeof (current_event
));
1325 push_target (&child_ops
);
1326 child_init_thread_list ();
1327 disable_breakpoints_in_shlibs (1);
1328 child_clear_solibs ();
1329 clear_proceed_status ();
1330 init_wait_for_inferior ();
1332 target_terminal_init ();
1333 target_terminal_inferior ();
1337 stop_after_trap
= 1;
1338 wait_for_inferior ();
1339 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1340 resume (0, stop_signal
);
1344 stop_after_trap
= 0;
1348 /* Since Windows XP, detaching from a process is supported by Windows.
1349 The following code tries loading the appropriate functions dynamically.
1350 If loading these functions succeeds use them to actually detach from
1351 the inferior process, otherwise behave as usual, pretending that
1352 detach has worked. */
1353 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1354 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1357 has_detach_ability (void)
1359 static HMODULE kernel32
= NULL
;
1362 kernel32
= LoadLibrary ("kernel32.dll");
1365 if (!DebugSetProcessKillOnExit
)
1366 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1367 "DebugSetProcessKillOnExit");
1368 if (!DebugActiveProcessStop
)
1369 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1370 "DebugActiveProcessStop");
1371 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1377 /* Try to set or remove a user privilege to the current process. Return -1
1378 if that fails, the previous setting of that privilege otherwise.
1380 This code is copied from the Cygwin source code and rearranged to allow
1381 dynamically loading of the needed symbols from advapi32 which is only
1382 available on NT/2K/XP. */
1384 set_process_privilege (const char *privilege
, BOOL enable
)
1386 static HMODULE advapi32
= NULL
;
1387 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1388 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1389 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1390 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1392 HANDLE token_hdl
= NULL
;
1394 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1398 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1403 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1405 if (!OpenProcessToken
)
1406 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1407 if (!LookupPrivilegeValue
)
1408 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1409 "LookupPrivilegeValueA");
1410 if (!AdjustTokenPrivileges
)
1411 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1412 "AdjustTokenPrivileges");
1413 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1420 if (!OpenProcessToken (GetCurrentProcess (),
1421 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1425 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1428 new_priv
.PrivilegeCount
= 1;
1429 new_priv
.Privileges
[0].Luid
= restore_priv
;
1430 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1432 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1433 sizeof orig_priv
, &orig_priv
, &size
))
1436 /* Disabled, otherwise every `attach' in an unprivileged user session
1437 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1439 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1440 be enabled. GetLastError () returns an correct error code, though. */
1441 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1445 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1449 CloseHandle (token_hdl
);
1454 /* Attach to process PID, then initialize for debugging it. */
1456 child_attach (char *args
, int from_tty
)
1462 error_no_arg ("process-id to attach");
1464 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1466 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1467 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1470 pid
= strtoul (args
, 0, 0);
1471 ok
= DebugActiveProcess (pid
);
1475 error ("Can't attach to process.");
1477 if (has_detach_ability ())
1480 DebugSetProcessKillOnExit (FALSE
);
1485 char *exec_file
= (char *) get_exec_file (0);
1488 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1489 target_pid_to_str (pid_to_ptid (pid
)));
1491 printf_unfiltered ("Attaching to %s\n",
1492 target_pid_to_str (pid_to_ptid (pid
)));
1494 gdb_flush (gdb_stdout
);
1497 do_initial_child_stuff (pid
);
1498 target_terminal_ours ();
1502 child_detach (char *args
, int from_tty
)
1506 if (has_detach_ability ())
1508 delete_command (NULL
, 0);
1509 child_continue (DBG_CONTINUE
, -1);
1510 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1512 error ("Can't detach process %lu (error %lu)",
1513 current_event
.dwProcessId
, GetLastError ());
1516 DebugSetProcessKillOnExit (FALSE
);
1518 if (detached
&& from_tty
)
1520 char *exec_file
= get_exec_file (0);
1523 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1524 current_event
.dwProcessId
);
1525 gdb_flush (gdb_stdout
);
1527 inferior_ptid
= null_ptid
;
1528 unpush_target (&child_ops
);
1531 /* Print status information about what we're accessing. */
1534 child_files_info (struct target_ops
*ignore
)
1536 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1537 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1542 child_open (char *arg
, int from_tty
)
1544 error ("Use the \"run\" command to start a Unix child process.");
1547 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1548 EXEC_FILE is the file to run.
1549 ALLARGS is a string containing the arguments to the program.
1550 ENV is the environment vector to pass. Errors reported with error(). */
1553 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1560 PROCESS_INFORMATION pi
;
1564 char real_path
[MAXPATHLEN
];
1566 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1569 int ostdin
, ostdout
, ostderr
;
1572 error ("No executable specified, use `target exec'.\n");
1574 memset (&si
, 0, sizeof (si
));
1575 si
.cb
= sizeof (si
);
1579 flags
= DEBUG_ONLY_THIS_PROCESS
;
1580 cygwin_conv_to_win32_path (exec_file
, real_path
);
1586 sh
= getenv ("SHELL");
1589 cygwin_conv_to_win32_path (sh
, shell
);
1590 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1591 + strlen (allargs
) + 2);
1592 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1593 allargs
= newallargs
;
1595 flags
= DEBUG_PROCESS
;
1599 flags
|= CREATE_NEW_PROCESS_GROUP
;
1602 flags
|= CREATE_NEW_CONSOLE
;
1604 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1605 strcpy (args
, toexec
);
1607 strcat (args
, allargs
);
1609 /* Prepare the environment vars for CreateProcess. */
1611 /* This code used to assume all env vars were file names and would
1612 translate them all to win32 style. That obviously doesn't work in the
1613 general case. The current rule is that we only translate PATH.
1614 We need to handle PATH because we're about to call CreateProcess and
1615 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1616 in both posix and win32 environments. cygwin.dll will change it back
1617 to posix style if necessary. */
1619 static const char *conv_path_names
[] =
1625 /* CreateProcess takes the environment list as a null terminated set of
1626 strings (i.e. two nulls terminate the list). */
1628 /* Get total size for env strings. */
1629 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1633 for (j
= 0; conv_path_names
[j
]; j
++)
1635 len
= strlen (conv_path_names
[j
]);
1636 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1638 if (cygwin_posix_path_list_p (env
[i
] + len
))
1640 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1642 envlen
+= strlen (env
[i
]) + 1;
1646 if (conv_path_names
[j
] == NULL
)
1647 envlen
+= strlen (env
[i
]) + 1;
1650 winenv
= alloca (envlen
+ 1);
1652 /* Copy env strings into new buffer. */
1653 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1657 for (j
= 0; conv_path_names
[j
]; j
++)
1659 len
= strlen (conv_path_names
[j
]);
1660 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1662 if (cygwin_posix_path_list_p (env
[i
] + len
))
1664 memcpy (temp
, env
[i
], len
);
1665 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1668 strcpy (temp
, env
[i
]);
1672 if (conv_path_names
[j
] == NULL
)
1673 strcpy (temp
, env
[i
]);
1675 temp
+= strlen (temp
) + 1;
1678 /* Final nil string to terminate new env. */
1682 if (!inferior_io_terminal
)
1683 tty
= ostdin
= ostdout
= ostderr
= -1;
1686 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1689 print_sys_errmsg (inferior_io_terminal
, errno
);
1690 ostdin
= ostdout
= ostderr
= -1;
1703 ret
= CreateProcess (0,
1704 args
, /* command line */
1705 NULL
, /* Security */
1707 TRUE
, /* inherit handles */
1708 flags
, /* start flags */
1710 NULL
, /* current directory */
1725 error ("Error creating process %s, (error %d)\n", exec_file
, (unsigned) GetLastError ());
1727 CloseHandle (pi
.hThread
);
1728 CloseHandle (pi
.hProcess
);
1730 if (useshell
&& shell
[0] != '\0')
1735 do_initial_child_stuff (pi
.dwProcessId
);
1737 /* child_continue (DBG_CONTINUE, -1); */
1738 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1742 child_mourn_inferior (void)
1744 (void) child_continue (DBG_CONTINUE
, -1);
1745 i386_cleanup_dregs();
1746 unpush_target (&child_ops
);
1747 generic_mourn_inferior ();
1750 /* Send a SIGINT to the process group. This acts just like the user typed a
1751 ^C on the controlling terminal. */
1756 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1757 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1758 registers_changed (); /* refresh register state */
1762 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1763 int write
, struct mem_attrib
*mem
,
1764 struct target_ops
*target
)
1769 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1770 len
, (DWORD
) memaddr
));
1771 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1773 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1777 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1778 len
, (DWORD
) memaddr
));
1779 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1786 child_kill_inferior (void)
1788 CHECK (TerminateProcess (current_process_handle
, 0));
1792 if (!child_continue (DBG_CONTINUE
, -1))
1794 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1796 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1800 CHECK (CloseHandle (current_process_handle
));
1802 /* this may fail in an attached process so don't check. */
1803 (void) CloseHandle (current_thread
->h
);
1804 target_mourn_inferior (); /* or just child_mourn_inferior? */
1808 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1811 DWORD continue_status
= DBG_CONTINUE
;
1813 int pid
= PIDGET (ptid
);
1815 if (sig
!= TARGET_SIGNAL_0
)
1817 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1819 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1821 else if (sig
== last_sig
)
1822 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1825 /* This code does not seem to work, because
1826 the kernel does probably not consider changes in the ExceptionRecord
1827 structure when passing the exception to the inferior.
1828 Note that this seems possible in the exception handler itself. */
1831 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1832 if (xlate
[i
].us
== sig
)
1834 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1836 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1839 if (continue_status
== DBG_CONTINUE
)
1841 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1845 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1849 last_sig
= TARGET_SIGNAL_0
;
1851 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1854 /* Get context for currently selected thread */
1855 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1860 /* Single step by setting t bit */
1861 child_fetch_inferior_registers (PS_REGNUM
);
1862 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1865 if (th
->context
.ContextFlags
)
1867 if (debug_registers_changed
)
1869 th
->context
.Dr0
= dr
[0];
1870 th
->context
.Dr1
= dr
[1];
1871 th
->context
.Dr2
= dr
[2];
1872 th
->context
.Dr3
= dr
[3];
1873 /* th->context.Dr6 = dr[6];
1874 FIXME: should we set dr6 also ?? */
1875 th
->context
.Dr7
= dr
[7];
1877 CHECK (SetThreadContext (th
->h
, &th
->context
));
1878 th
->context
.ContextFlags
= 0;
1882 /* Allow continuing with the same signal that interrupted us.
1883 Otherwise complain. */
1885 child_continue (continue_status
, pid
);
1889 child_prepare_to_store (void)
1891 /* Do nothing, since we can store individual regs */
1895 child_can_run (void)
1903 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1904 PIDGET (inferior_ptid
)));
1907 struct target_ops child_ops
;
1910 init_child_ops (void)
1912 child_ops
.to_shortname
= "child";
1913 child_ops
.to_longname
= "Win32 child process";
1914 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1915 child_ops
.to_open
= child_open
;
1916 child_ops
.to_close
= child_close
;
1917 child_ops
.to_attach
= child_attach
;
1918 child_ops
.to_detach
= child_detach
;
1919 child_ops
.to_resume
= child_resume
;
1920 child_ops
.to_wait
= child_wait
;
1921 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1922 child_ops
.to_store_registers
= child_store_inferior_registers
;
1923 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1924 child_ops
.to_xfer_memory
= child_xfer_memory
;
1925 child_ops
.to_files_info
= child_files_info
;
1926 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1927 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1928 child_ops
.to_terminal_init
= terminal_init_inferior
;
1929 child_ops
.to_terminal_inferior
= terminal_inferior
;
1930 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1931 child_ops
.to_terminal_ours
= terminal_ours
;
1932 child_ops
.to_terminal_save_ours
= terminal_save_ours
;
1933 child_ops
.to_terminal_info
= child_terminal_info
;
1934 child_ops
.to_kill
= child_kill_inferior
;
1935 child_ops
.to_create_inferior
= child_create_inferior
;
1936 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1937 child_ops
.to_can_run
= child_can_run
;
1938 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1939 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1940 child_ops
.to_stop
= child_stop
;
1941 child_ops
.to_stratum
= process_stratum
;
1942 child_ops
.to_has_all_memory
= 1;
1943 child_ops
.to_has_memory
= 1;
1944 child_ops
.to_has_stack
= 1;
1945 child_ops
.to_has_registers
= 1;
1946 child_ops
.to_has_execution
= 1;
1947 child_ops
.to_magic
= OPS_MAGIC
;
1951 _initialize_win32_nat (void)
1953 struct cmd_list_element
*c
;
1957 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1958 "Load dll library symbols from FILE.");
1959 set_cmd_completer (c
, filename_completer
);
1961 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1963 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
1965 "Set use of shell to start subprocess.",
1969 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1970 (char *) &new_console
,
1971 "Set creation of new console when creating child process.",
1975 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1976 (char *) &new_group
,
1977 "Set creation of new group when creating child process.",
1981 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1982 (char *) &debug_exec
,
1983 "Set whether to display execution in child process.",
1987 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1988 (char *) &debug_events
,
1989 "Set whether to display kernel events in child process.",
1993 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1994 (char *) &debug_memory
,
1995 "Set whether to display memory accesses in child process.",
1999 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
2000 (char *) &debug_exceptions
,
2001 "Set whether to display kernel exceptions in child process.",
2005 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
2006 add_info_alias ("sharedlibrary", "dll", 1);
2008 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2009 "Print information specific to Win32 debugging.",
2010 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2012 add_cmd ("selector", class_info
, display_selectors
,
2013 "Display selectors infos.",
2016 add_target (&child_ops
);
2019 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2021 /* Pass the address ADDR to the inferior in the I'th debug register.
2022 Here we just store the address in dr array, the registers will be
2023 actually set up when child_continue is called. */
2025 cygwin_set_dr (int i
, CORE_ADDR addr
)
2028 internal_error (__FILE__
, __LINE__
,
2029 "Invalid register %d in cygwin_set_dr.\n", i
);
2030 dr
[i
] = (unsigned) addr
;
2031 debug_registers_changed
= 1;
2032 debug_registers_used
= 1;
2035 /* Pass the value VAL to the inferior in the DR7 debug control
2036 register. Here we just store the address in D_REGS, the watchpoint
2037 will be actually set up in child_wait. */
2039 cygwin_set_dr7 (unsigned val
)
2042 debug_registers_changed
= 1;
2043 debug_registers_used
= 1;
2046 /* Get the value of the DR6 debug status register from the inferior.
2047 Here we just return the value stored in dr[6]
2048 by the last call to thread_rec for current_event.dwThreadId id. */
2050 cygwin_get_dr6 (void)
2056 /* Determine if the thread referenced by "pid" is alive
2057 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2058 it means that the pid has died. Otherwise it is assumed to be alive. */
2060 win32_child_thread_alive (ptid_t ptid
)
2062 int pid
= PIDGET (ptid
);
2064 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2068 /* Convert pid to printable format. */
2070 cygwin_pid_to_str (ptid_t ptid
)
2072 static char buf
[80];
2073 int pid
= PIDGET (ptid
);
2075 if ((DWORD
) pid
== current_event
.dwProcessId
)
2076 sprintf (buf
, "process %d", pid
);
2078 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2083 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
2085 struct objfile
*objfile
;
2086 char *objfile_basename
;
2087 const char *dll_basename
;
2089 if (!(dll_basename
= strrchr (dll_name
, '/')))
2090 dll_basename
= dll_name
;
2094 ALL_OBJFILES (objfile
)
2096 objfile_basename
= strrchr (objfile
->name
, '/');
2098 if (objfile_basename
&&
2099 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
2101 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2102 base_addr
, dll_name
);
2107 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
2108 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
2116 struct target_ops
*target
;
2119 map_code_section_args
;
2122 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2126 struct section_table
*new_target_sect_ptr
;
2128 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2129 struct target_ops
*target
= args
->target
;
2130 if (sect
->flags
& SEC_CODE
)
2132 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2134 if (target
->to_sections
)
2136 old
= target
->to_sections_end
- target
->to_sections
;
2137 target
->to_sections
= (struct section_table
*)
2138 xrealloc ((char *) target
->to_sections
,
2139 (sizeof (struct section_table
)) * (1 + old
));
2144 target
->to_sections
= (struct section_table
*)
2145 xmalloc ((sizeof (struct section_table
)));
2147 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2149 /* Update the to_sections field in the core_ops structure
2153 core_ops
.to_sections
= target
->to_sections
;
2154 core_ops
.to_sections_end
= target
->to_sections_end
;
2156 new_target_sect_ptr
= target
->to_sections
+ old
;
2157 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2158 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2159 bfd_section_size (abfd
, sect
);;
2160 new_target_sect_ptr
->the_bfd_section
= sect
;
2161 new_target_sect_ptr
->bfd
= abfd
;
2166 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2169 map_code_section_args map_args
;
2170 asection
*lowest_sect
;
2172 if (dll_name
== NULL
|| target
== NULL
)
2174 name
= xstrdup (dll_name
);
2175 dll_bfd
= bfd_openr (name
, "pei-i386");
2176 if (dll_bfd
== NULL
)
2179 if (bfd_check_format (dll_bfd
, bfd_object
))
2181 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2182 if (lowest_sect
== NULL
)
2184 map_args
.target
= target
;
2185 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2187 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2194 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2196 struct target_ops
*target
= (struct target_ops
*) obj
;
2201 char *dll_name
= NULL
;
2203 struct win32_pstatus
*pstatus
;
2206 if (strncmp (sect
->name
, ".module", 7))
2209 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2212 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2215 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2218 pstatus
= (struct win32_pstatus
*) buf
;
2220 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2221 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2222 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2225 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2228 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2231 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2233 while ((p
= strchr (dll_name
, '\\')))
2236 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2237 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2239 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2240 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2251 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2258 child_clear_solibs ();
2259 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2263 if (solib_end
&& solib_end
->name
)
2264 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2265 solib_end
->load_addr
);
2270 fetch_elf_core_registers (char *core_reg_sect
,
2271 unsigned core_reg_size
,
2276 if (core_reg_size
< sizeof (CONTEXT
))
2278 error ("Core file register section too small (%u bytes).", core_reg_size
);
2281 for (r
= 0; r
< NUM_REGS
; r
++)
2282 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2285 static struct core_fns win32_elf_core_fns
=
2287 bfd_target_elf_flavour
,
2288 default_check_format
,
2289 default_core_sniffer
,
2290 fetch_elf_core_registers
,
2295 _initialize_core_win32 (void)
2297 add_core_fns (&win32_elf_core_fns
);
2301 _initialize_check_for_gdb_ini (void)
2304 if (inhibit_gdbinit
)
2307 homedir
= getenv ("HOME");
2311 char *oldini
= (char *) alloca (strlen (homedir
) +
2312 sizeof ("/gdb.ini"));
2313 strcpy (oldini
, homedir
);
2314 p
= strchr (oldini
, '\0');
2315 if (p
> oldini
&& p
[-1] != '/')
2317 strcpy (p
, "gdb.ini");
2318 if (access (oldini
, 0) == 0)
2320 int len
= strlen (oldini
);
2321 char *newini
= alloca (len
+ 1);
2322 sprintf (newini
, "%.*s.gdbinit",
2323 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2324 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);