1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007 Free 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 3 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 even the 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, see <http://www.gnu.org/licenses/>. */
23 /* Originally by Steve Chamberlain, sac@cygnus.com */
26 #include "frame.h" /* required by inferior.h */
29 #include "exceptions.h"
32 #include "completer.h"
36 #include <sys/types.h>
42 #include <sys/cygwin.h>
49 #include "gdb_obstack.h"
50 #include "gdb_string.h"
51 #include "gdb_stdint.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
59 #include "xml-support.h"
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 #include "i386-cygwin-tdep.h"
66 static struct target_ops win32_ops
;
69 /* The starting and ending address of the cygwin1.dll text segment. */
70 static bfd_vma cygwin_load_start
;
71 static bfd_vma cygwin_load_end
;
74 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
75 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
77 /* If we're not using the old Cygwin header file set, define the
78 following which never should have been in the generic Win32 API
79 headers in the first place since they were our own invention... */
80 #ifndef _GNU_H_WINDOWS_H
83 FLAG_TRACE_BIT
= 0x100,
84 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
89 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
90 | CONTEXT_EXTENDED_REGISTERS
92 static unsigned dr
[8];
93 static int debug_registers_changed
;
94 static int debug_registers_used
;
95 #define DR6_CLEAR_VALUE 0xffff0ff0
97 /* The string sent by cygwin when it processes a signal.
98 FIXME: This should be in a cygwin include file. */
99 #ifndef _CYGWIN_SIGNAL_STRING
100 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
103 #define CHECK(x) check (x, __FILE__,__LINE__)
104 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
105 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
106 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
107 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
109 static void win32_stop (void);
110 static int win32_win32_thread_alive (ptid_t
);
111 static void win32_kill_inferior (void);
113 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
114 /* Set if a signal was received from the debugged process */
116 /* Thread information structure used to track information that is
117 not available in gdb's thread structure. */
118 typedef struct thread_info_struct
120 struct thread_info_struct
*next
;
131 static thread_info thread_head
;
133 /* The process and thread handles for the above context. */
135 static DEBUG_EVENT current_event
; /* The current debug event from
137 static HANDLE current_process_handle
; /* Currently executing process */
138 static thread_info
*current_thread
; /* Info on currently selected thread */
139 static DWORD main_thread_id
; /* Thread ID of the main thread */
141 /* Counts of things. */
142 static int exception_count
= 0;
143 static int event_count
= 0;
144 static int saw_create
;
145 static int open_process_used
= 0;
148 static int new_console
= 0;
150 static int cygwin_exceptions
= 0;
152 static int new_group
= 1;
153 static int debug_exec
= 0; /* show execution */
154 static int debug_events
= 0; /* show events from kernel */
155 static int debug_memory
= 0; /* show target memory accesses */
156 static int debug_exceptions
= 0; /* show target exceptions */
157 static int useshell
= 0; /* use shell for subprocesses */
159 /* This vector maps GDB's idea of a register's number into an address
160 in the win32 exception context vector.
162 It also contains the bit mask needed to load the register in question.
164 One day we could read a reg, we could inspect the context we
165 already have loaded, if it doesn't have the bit set that we need,
166 we read that set of registers in using GetThreadContext. If the
167 context already contains what we need, we just unpack it. Then to
168 write a register, first we have to ensure that the context contains
169 the other regs of the group, and then we copy the info in and set
172 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
173 static const int mappings
[] =
175 context_offset (Eax
),
176 context_offset (Ecx
),
177 context_offset (Edx
),
178 context_offset (Ebx
),
179 context_offset (Esp
),
180 context_offset (Ebp
),
181 context_offset (Esi
),
182 context_offset (Edi
),
183 context_offset (Eip
),
184 context_offset (EFlags
),
185 context_offset (SegCs
),
186 context_offset (SegSs
),
187 context_offset (SegDs
),
188 context_offset (SegEs
),
189 context_offset (SegFs
),
190 context_offset (SegGs
),
191 context_offset (FloatSave
.RegisterArea
[0 * 10]),
192 context_offset (FloatSave
.RegisterArea
[1 * 10]),
193 context_offset (FloatSave
.RegisterArea
[2 * 10]),
194 context_offset (FloatSave
.RegisterArea
[3 * 10]),
195 context_offset (FloatSave
.RegisterArea
[4 * 10]),
196 context_offset (FloatSave
.RegisterArea
[5 * 10]),
197 context_offset (FloatSave
.RegisterArea
[6 * 10]),
198 context_offset (FloatSave
.RegisterArea
[7 * 10]),
199 context_offset (FloatSave
.ControlWord
),
200 context_offset (FloatSave
.StatusWord
),
201 context_offset (FloatSave
.TagWord
),
202 context_offset (FloatSave
.ErrorSelector
),
203 context_offset (FloatSave
.ErrorOffset
),
204 context_offset (FloatSave
.DataSelector
),
205 context_offset (FloatSave
.DataOffset
),
206 context_offset (FloatSave
.ErrorSelector
)
208 context_offset (ExtendedRegisters
[10*16]),
209 context_offset (ExtendedRegisters
[11*16]),
210 context_offset (ExtendedRegisters
[12*16]),
211 context_offset (ExtendedRegisters
[13*16]),
212 context_offset (ExtendedRegisters
[14*16]),
213 context_offset (ExtendedRegisters
[15*16]),
214 context_offset (ExtendedRegisters
[16*16]),
215 context_offset (ExtendedRegisters
[17*16]),
217 context_offset (ExtendedRegisters
[24])
220 #undef context_offset
222 /* This vector maps the target's idea of an exception (extracted
223 from the DEBUG_EVENT structure) to GDB's idea. */
225 struct xlate_exception
228 enum target_signal us
;
231 static const struct xlate_exception
234 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
235 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
236 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
237 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
238 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
239 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
243 check (BOOL ok
, const char *file
, int line
)
246 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
250 /* Find a thread record given a thread id. If GET_CONTEXT is not 0,
251 then also retrieve the context for this thread. If GET_CONTEXT is
252 negative, then don't suspend the thread. */
254 thread_rec (DWORD id
, int get_context
)
258 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
261 if (!th
->suspended
&& get_context
)
263 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
265 if (SuspendThread (th
->h
) == (DWORD
) -1)
267 DWORD err
= GetLastError ();
268 warning (_("SuspendThread failed. (winerr %d)"),
274 else if (get_context
< 0)
276 th
->reload_context
= 1;
284 /* Add a thread to the thread list */
286 win32_add_thread (DWORD id
, HANDLE h
)
290 if ((th
= thread_rec (id
, FALSE
)))
293 th
= XZALLOC (thread_info
);
296 th
->next
= thread_head
.next
;
297 thread_head
.next
= th
;
298 add_thread (pid_to_ptid (id
));
299 /* Set the debug registers for the new thread in they are used. */
300 if (debug_registers_used
)
302 /* Only change the value of the debug registers. */
303 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
304 CHECK (GetThreadContext (th
->h
, &th
->context
));
305 th
->context
.Dr0
= dr
[0];
306 th
->context
.Dr1
= dr
[1];
307 th
->context
.Dr2
= dr
[2];
308 th
->context
.Dr3
= dr
[3];
309 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
310 th
->context
.Dr7
= dr
[7];
311 CHECK (SetThreadContext (th
->h
, &th
->context
));
312 th
->context
.ContextFlags
= 0;
317 /* Clear out any old thread list and reintialize it to a
320 win32_init_thread_list (void)
322 thread_info
*th
= &thread_head
;
324 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
326 while (th
->next
!= NULL
)
328 thread_info
*here
= th
->next
;
329 th
->next
= here
->next
;
332 thread_head
.next
= NULL
;
335 /* Delete a thread from the list of threads */
337 win32_delete_thread (DWORD id
)
342 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
343 delete_thread (pid_to_ptid (id
));
345 for (th
= &thread_head
;
346 th
->next
!= NULL
&& th
->next
->id
!= id
;
350 if (th
->next
!= NULL
)
352 thread_info
*here
= th
->next
;
353 th
->next
= here
->next
;
359 do_win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
361 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
365 return; /* Windows sometimes uses a non-existent thread id in its
368 if (current_thread
->reload_context
)
370 #ifdef __COPY_CONTEXT_SIZE
371 if (have_saved_context
)
373 /* Lie about where the program actually is stopped since cygwin has informed us that
374 we should consider the signal to have occurred at another location which is stored
375 in "saved_context. */
376 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
377 have_saved_context
= 0;
382 thread_info
*th
= current_thread
;
383 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
384 GetThreadContext (th
->h
, &th
->context
);
385 /* Copy dr values from that thread.
386 But only if there were not modified since last stop. PR gdb/2388 */
387 if (!debug_registers_changed
)
389 dr
[0] = th
->context
.Dr0
;
390 dr
[1] = th
->context
.Dr1
;
391 dr
[2] = th
->context
.Dr2
;
392 dr
[3] = th
->context
.Dr3
;
393 dr
[6] = th
->context
.Dr6
;
394 dr
[7] = th
->context
.Dr7
;
397 current_thread
->reload_context
= 0;
400 #define I387_ST0_REGNUM I386_ST0_REGNUM
402 if (r
== I387_FISEG_REGNUM
)
404 l
= *((long *) context_offset
) & 0xffff;
405 regcache_raw_supply (regcache
, r
, (char *) &l
);
407 else if (r
== I387_FOP_REGNUM
)
409 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
410 regcache_raw_supply (regcache
, r
, (char *) &l
);
413 regcache_raw_supply (regcache
, r
, context_offset
);
416 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
417 do_win32_fetch_inferior_registers (regcache
, r
);
420 #undef I387_ST0_REGNUM
424 win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
426 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
427 /* Check if current_thread exists. Windows sometimes uses a non-existent
428 thread id in its events */
430 do_win32_fetch_inferior_registers (regcache
, r
);
434 do_win32_store_inferior_registers (const struct regcache
*regcache
, int r
)
437 /* Windows sometimes uses a non-existent thread id in its events */;
439 regcache_raw_collect (regcache
, r
,
440 ((char *) ¤t_thread
->context
) + mappings
[r
]);
443 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
444 do_win32_store_inferior_registers (regcache
, r
);
448 /* Store a new register value into the current thread context */
450 win32_store_inferior_registers (struct regcache
*regcache
, int r
)
452 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
453 /* Check if current_thread exists. Windows sometimes uses a non-existent
454 thread id in its events */
456 do_win32_store_inferior_registers (regcache
, r
);
459 static int psapi_loaded
= 0;
460 static HMODULE psapi_module_handle
= NULL
;
461 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
462 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
463 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
466 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
472 HMODULE
*DllHandle
= dh_buf
;
477 psapi_EnumProcessModules
== NULL
||
478 psapi_GetModuleInformation
== NULL
||
479 psapi_GetModuleFileNameExA
== NULL
)
484 psapi_module_handle
= LoadLibrary ("psapi.dll");
485 if (!psapi_module_handle
)
487 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
490 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
491 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
492 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
493 "GetModuleFileNameExA");
494 if (psapi_EnumProcessModules
== NULL
||
495 psapi_GetModuleInformation
== NULL
||
496 psapi_GetModuleFileNameExA
== NULL
)
501 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
506 if (!ok
|| !cbNeeded
)
509 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
513 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
520 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
522 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
526 error (_("Can't get module info"));
528 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
533 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
535 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
540 dll_name_ret
[0] = '\0';
544 /* Encapsulate the information required in a call to
545 symbol_file_add_args */
546 struct safe_symbol_file_add_args
550 struct section_addr_info
*addrs
;
553 struct ui_file
*err
, *out
;
557 /* Maintain a linked list of "so" information. */
563 static struct so_list solib_start
, *solib_end
;
565 /* Call symbol_file_add with stderr redirected. We don't care if there
568 safe_symbol_file_add_stub (void *argv
)
570 #define p ((struct safe_symbol_file_add_args *) argv)
571 struct so_list
*so
= &solib_start
;
573 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
578 /* Restore gdb's stderr after calling symbol_file_add */
580 safe_symbol_file_add_cleanup (void *p
)
582 #define sp ((struct safe_symbol_file_add_args *)p)
583 gdb_flush (gdb_stderr
);
584 gdb_flush (gdb_stdout
);
585 ui_file_delete (gdb_stderr
);
586 ui_file_delete (gdb_stdout
);
587 gdb_stderr
= sp
->err
;
588 gdb_stdout
= sp
->out
;
592 /* symbol_file_add wrapper that prevents errors from being displayed. */
593 static struct objfile
*
594 safe_symbol_file_add (char *name
, int from_tty
,
595 struct section_addr_info
*addrs
,
596 int mainline
, int flags
)
598 struct safe_symbol_file_add_args p
;
599 struct cleanup
*cleanup
;
601 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
605 gdb_flush (gdb_stderr
);
606 gdb_flush (gdb_stdout
);
607 gdb_stderr
= ui_file_new ();
608 gdb_stdout
= ui_file_new ();
610 p
.from_tty
= from_tty
;
612 p
.mainline
= mainline
;
614 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
616 do_cleanups (cleanup
);
620 static struct so_list
*
621 win32_make_so (const char *name
, DWORD load_addr
)
624 char buf
[MAX_PATH
+ 1];
625 char cwd
[MAX_PATH
+ 1];
627 WIN32_FIND_DATA w32_fd
;
628 HANDLE h
= FindFirstFile(name
, &w32_fd
);
629 MEMORY_BASIC_INFORMATION m
;
631 if (h
== INVALID_HANDLE_VALUE
)
637 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
639 p
= strrchr (buf
, '\\');
642 SetCurrentDirectory (buf
);
643 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
644 SetCurrentDirectory (cwd
);
648 if (strcasecmp (buf
, "ntdll.dll") == 0)
650 GetSystemDirectory (buf
, sizeof (buf
));
651 strcat (buf
, "\\ntdll.dll");
653 so
= XZALLOC (struct so_list
);
654 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
655 so
->lm_info
->load_addr
= load_addr
;
656 strcpy (so
->so_original_name
, name
);
658 strcpy (so
->so_name
, buf
);
660 cygwin_conv_to_posix_path (buf
, so
->so_name
);
661 /* Record cygwin1.dll .text start/end. */
662 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
663 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
666 asection
*text
= NULL
;
669 abfd
= bfd_openr (name
, "pei-i386");
674 if (bfd_check_format (abfd
, bfd_object
))
675 text
= bfd_get_section_by_name (abfd
, ".text");
683 /* The symbols in a dll are offset by 0x1000, which is the the
684 offset from 0 of the first byte in an image - because of the
685 file header and the section alignment. */
686 cygwin_load_start
= load_addr
+ 0x1000;
687 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
697 get_image_name (HANDLE h
, void *address
, int unicode
)
699 static char buf
[(2 * MAX_PATH
) + 1];
700 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
706 /* Attempt to read the name of the dll that was detected.
707 This is documented to work only when actively debugging
708 a program. It will not work for attached processes. */
712 /* See if we could read the address of a string, and that the
713 address isn't null. */
714 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
715 || done
!= sizeof (address_ptr
) || !address_ptr
)
718 /* Find the length of the string */
719 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
720 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
724 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
727 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
728 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
731 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
737 /* Wait for child to do something. Return pid of child, or -1 in case
738 of error; store status through argument pointer OURSTATUS. */
740 handle_load_dll (void *dummy
)
742 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
743 char dll_buf
[MAX_PATH
+ 1];
744 char *dll_name
= NULL
;
746 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
748 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
749 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
753 if (*dll_name
== '\0')
754 dll_name
= get_image_name (current_process_handle
,
755 event
->lpImageName
, event
->fUnicode
);
759 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
760 solib_end
= solib_end
->next
;
766 win32_free_so (struct so_list
*so
)
774 handle_unload_dll (void *dummy
)
776 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
779 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
780 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
782 struct so_list
*sodel
= so
->next
;
783 so
->next
= sodel
->next
;
786 win32_free_so (sodel
);
787 solib_add (NULL
, 0, NULL
, auto_solib_add
);
791 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
796 /* Clear list of loaded DLLs. */
798 win32_clear_solib (void)
800 solib_start
.next
= NULL
;
801 solib_end
= &solib_start
;
804 /* Load DLL symbol info. */
806 dll_symbol_command (char *args
, int from_tty
)
812 error (_("dll-symbols requires a file name"));
815 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
817 char *newargs
= (char *) alloca (n
+ 4 + 1);
818 strcpy (newargs
, args
);
819 strcat (newargs
, ".dll");
823 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
826 /* Handle DEBUG_STRING output from child process.
827 Cygwin prepends its messages with a "cygwin:". Interpret this as
828 a Cygwin signal. Otherwise just print the string as a warning. */
830 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
835 if (!target_read_string
836 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
840 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
843 if (strncmp (s
, "cYg", 3) != 0)
847 #ifdef __COPY_CONTEXT_SIZE
850 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
851 itself and then optionally followed by the thread id and address to saved context
852 within the DLL. If these are supplied, then the given thread is assumed to have
853 issued the signal and the context from the thread is assumed to be stored at the
854 given address in the inferior. Tell gdb to treat this like a real signal. */
856 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
857 int gotasig
= target_signal_from_host (sig
);
858 ourstatus
->value
.sig
= gotasig
;
863 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
864 retval
= strtoul (p
, &p
, 0);
866 retval
= main_thread_id
;
867 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
868 && ReadProcessMemory (current_process_handle
, x
,
869 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
870 && n
== __COPY_CONTEXT_SIZE
)
871 have_saved_context
= 1;
872 current_event
.dwThreadId
= retval
;
883 display_selector (HANDLE thread
, DWORD sel
)
886 if (GetThreadSelectorEntry (thread
, sel
, &info
))
889 printf_filtered ("0x%03lx: ", sel
);
890 if (!info
.HighWord
.Bits
.Pres
)
892 puts_filtered ("Segment not present\n");
895 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
896 (info
.HighWord
.Bits
.BaseMid
<< 16)
898 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
899 if (info
.HighWord
.Bits
.Granularity
)
900 limit
= (limit
<< 12) | 0xfff;
901 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
902 if (info
.HighWord
.Bits
.Default_Big
)
903 puts_filtered(" 32-bit ");
905 puts_filtered(" 16-bit ");
906 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
909 puts_filtered ("Data (Read-Only, Exp-up");
912 puts_filtered ("Data (Read/Write, Exp-up");
915 puts_filtered ("Unused segment (");
918 puts_filtered ("Data (Read/Write, Exp-down");
921 puts_filtered ("Code (Exec-Only, N.Conf");
924 puts_filtered ("Code (Exec/Read, N.Conf");
927 puts_filtered ("Code (Exec-Only, Conf");
930 puts_filtered ("Code (Exec/Read, Conf");
933 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
935 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
936 puts_filtered(", N.Acc");
937 puts_filtered (")\n");
938 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
939 puts_filtered("System selector ");
940 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
941 if (info
.HighWord
.Bits
.Granularity
)
942 puts_filtered ("Page granular.\n");
944 puts_filtered ("Byte granular.\n");
949 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
955 display_selectors (char * args
, int from_tty
)
959 puts_filtered ("Impossible to display selectors now.\n");
965 puts_filtered ("Selector $cs\n");
966 display_selector (current_thread
->h
,
967 current_thread
->context
.SegCs
);
968 puts_filtered ("Selector $ds\n");
969 display_selector (current_thread
->h
,
970 current_thread
->context
.SegDs
);
971 puts_filtered ("Selector $es\n");
972 display_selector (current_thread
->h
,
973 current_thread
->context
.SegEs
);
974 puts_filtered ("Selector $ss\n");
975 display_selector (current_thread
->h
,
976 current_thread
->context
.SegSs
);
977 puts_filtered ("Selector $fs\n");
978 display_selector (current_thread
->h
,
979 current_thread
->context
.SegFs
);
980 puts_filtered ("Selector $gs\n");
981 display_selector (current_thread
->h
,
982 current_thread
->context
.SegGs
);
987 sel
= parse_and_eval_long (args
);
988 printf_filtered ("Selector \"%s\"\n",args
);
989 display_selector (current_thread
->h
, sel
);
993 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
996 info_w32_command (char *args
, int from_tty
)
998 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1002 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1003 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1004 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1007 handle_exception (struct target_waitstatus
*ourstatus
)
1010 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1012 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1014 /* Record the context of the current thread */
1015 th
= thread_rec (current_event
.dwThreadId
, -1);
1019 case EXCEPTION_ACCESS_VIOLATION
:
1020 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1021 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1024 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1025 a kind of exception handling to deal with passed-in invalid addresses. gdb
1026 should not treat these as real SEGVs since they will be silently handled by
1027 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1028 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1029 within the text segment of the DLL itself. */
1031 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1032 ExceptionRecord
.ExceptionAddress
;
1033 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1034 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1035 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1040 case STATUS_STACK_OVERFLOW
:
1041 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1044 case STATUS_FLOAT_DENORMAL_OPERAND
:
1045 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1046 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1048 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1049 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1050 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1052 case STATUS_FLOAT_INEXACT_RESULT
:
1053 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1054 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1056 case STATUS_FLOAT_INVALID_OPERATION
:
1057 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1058 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1060 case STATUS_FLOAT_OVERFLOW
:
1061 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1062 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1064 case STATUS_FLOAT_STACK_CHECK
:
1065 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1066 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1068 case STATUS_FLOAT_UNDERFLOW
:
1069 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1070 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1072 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1073 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1074 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1076 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1077 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1078 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1080 case STATUS_INTEGER_OVERFLOW
:
1081 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1082 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1084 case EXCEPTION_BREAKPOINT
:
1085 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1086 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1089 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1090 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1092 case DBG_CONTROL_BREAK
:
1093 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1094 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1096 case EXCEPTION_SINGLE_STEP
:
1097 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1098 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1100 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1101 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1102 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1104 case EXCEPTION_PRIV_INSTRUCTION
:
1105 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1106 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1108 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1109 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1110 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1113 /* Treat unhandled first chance exceptions specially. */
1114 if (current_event
.u
.Exception
.dwFirstChance
)
1116 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1117 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1118 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1119 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1123 last_sig
= ourstatus
->value
.sig
;
1127 /* Resume all artificially suspended threads if we are continuing
1130 win32_continue (DWORD continue_status
, int id
)
1136 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1137 current_event
.dwProcessId
, current_event
.dwThreadId
,
1138 continue_status
== DBG_CONTINUE
?
1139 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1141 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1142 if ((id
== -1 || id
== (int) th
->id
)
1145 if (debug_registers_changed
)
1147 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1148 th
->context
.Dr0
= dr
[0];
1149 th
->context
.Dr1
= dr
[1];
1150 th
->context
.Dr2
= dr
[2];
1151 th
->context
.Dr3
= dr
[3];
1152 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1153 th
->context
.Dr7
= dr
[7];
1155 if (th
->context
.ContextFlags
)
1157 CHECK (SetThreadContext (th
->h
, &th
->context
));
1158 th
->context
.ContextFlags
= 0;
1160 if (th
->suspended
> 0)
1161 (void) ResumeThread (th
->h
);
1165 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1166 current_event
.dwThreadId
,
1169 debug_registers_changed
= 0;
1173 /* Called in pathological case where Windows fails to send a
1174 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1176 fake_create_process (void)
1178 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1179 current_event
.dwProcessId
);
1180 if (current_process_handle
!= NULL
)
1181 open_process_used
= 1;
1184 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1186 /* We can not debug anything in that case. */
1188 main_thread_id
= current_event
.dwThreadId
;
1189 current_thread
= win32_add_thread (main_thread_id
,
1190 current_event
.u
.CreateThread
.hThread
);
1191 return main_thread_id
;
1195 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1198 DWORD continue_status
= DBG_CONTINUE
;
1200 int pid
= PIDGET (ptid
);
1202 if (sig
!= TARGET_SIGNAL_0
)
1204 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1206 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1208 else if (sig
== last_sig
)
1209 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1212 /* This code does not seem to work, because
1213 the kernel does probably not consider changes in the ExceptionRecord
1214 structure when passing the exception to the inferior.
1215 Note that this seems possible in the exception handler itself. */
1218 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1219 if (xlate
[i
].us
== sig
)
1221 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1223 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1226 if (continue_status
== DBG_CONTINUE
)
1228 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1232 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1236 last_sig
= TARGET_SIGNAL_0
;
1238 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1241 /* Get context for currently selected thread */
1242 th
= thread_rec (PIDGET (inferior_ptid
), FALSE
);
1247 /* Single step by setting t bit */
1248 win32_fetch_inferior_registers (get_current_regcache (),
1249 gdbarch_ps_regnum (current_gdbarch
));
1250 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1253 if (th
->context
.ContextFlags
)
1255 if (debug_registers_changed
)
1257 th
->context
.Dr0
= dr
[0];
1258 th
->context
.Dr1
= dr
[1];
1259 th
->context
.Dr2
= dr
[2];
1260 th
->context
.Dr3
= dr
[3];
1261 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1262 th
->context
.Dr7
= dr
[7];
1264 CHECK (SetThreadContext (th
->h
, &th
->context
));
1265 th
->context
.ContextFlags
= 0;
1269 /* Allow continuing with the same signal that interrupted us.
1270 Otherwise complain. */
1272 win32_continue (continue_status
, pid
);
1275 /* Get the next event from the child. Return 1 if the event requires
1276 handling by WFI (or whatever).
1279 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1282 DWORD continue_status
, event_code
;
1284 static thread_info dummy_thread_info
;
1288 last_sig
= TARGET_SIGNAL_0
;
1290 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1294 continue_status
= DBG_CONTINUE
;
1296 event_code
= current_event
.dwDebugEventCode
;
1297 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1299 have_saved_context
= 0;
1303 case CREATE_THREAD_DEBUG_EVENT
:
1304 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1305 (unsigned) current_event
.dwProcessId
,
1306 (unsigned) current_event
.dwThreadId
,
1307 "CREATE_THREAD_DEBUG_EVENT"));
1308 if (saw_create
!= 1)
1310 if (!saw_create
&& attach_flag
)
1312 /* Kludge around a Windows bug where first event is a create
1313 thread event. Caused when attached process does not have
1315 retval
= ourstatus
->value
.related_pid
= fake_create_process ();
1321 /* Record the existence of this thread */
1322 th
= win32_add_thread (current_event
.dwThreadId
,
1323 current_event
.u
.CreateThread
.hThread
);
1325 printf_unfiltered ("[New %s]\n",
1327 pid_to_ptid (current_event
.dwThreadId
)));
1328 retval
= current_event
.dwThreadId
;
1331 case EXIT_THREAD_DEBUG_EVENT
:
1332 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1333 (unsigned) current_event
.dwProcessId
,
1334 (unsigned) current_event
.dwThreadId
,
1335 "EXIT_THREAD_DEBUG_EVENT"));
1336 if (current_event
.dwThreadId
!= main_thread_id
)
1338 win32_delete_thread (current_event
.dwThreadId
);
1339 th
= &dummy_thread_info
;
1343 case CREATE_PROCESS_DEBUG_EVENT
:
1344 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1345 (unsigned) current_event
.dwProcessId
,
1346 (unsigned) current_event
.dwThreadId
,
1347 "CREATE_PROCESS_DEBUG_EVENT"));
1348 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1349 if (++saw_create
!= 1)
1352 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1354 win32_delete_thread (main_thread_id
);
1355 main_thread_id
= current_event
.dwThreadId
;
1356 /* Add the main thread */
1357 th
= win32_add_thread (main_thread_id
,
1358 current_event
.u
.CreateProcessInfo
.hThread
);
1359 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1362 case EXIT_PROCESS_DEBUG_EVENT
:
1363 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1364 (unsigned) current_event
.dwProcessId
,
1365 (unsigned) current_event
.dwThreadId
,
1366 "EXIT_PROCESS_DEBUG_EVENT"));
1367 if (saw_create
!= 1)
1369 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1370 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1371 retval
= main_thread_id
;
1374 case LOAD_DLL_DEBUG_EVENT
:
1375 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1376 (unsigned) current_event
.dwProcessId
,
1377 (unsigned) current_event
.dwThreadId
,
1378 "LOAD_DLL_DEBUG_EVENT"));
1379 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1380 if (saw_create
!= 1)
1382 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1383 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1384 ourstatus
->value
.integer
= 0;
1385 retval
= main_thread_id
;
1388 case UNLOAD_DLL_DEBUG_EVENT
:
1389 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1390 (unsigned) current_event
.dwProcessId
,
1391 (unsigned) current_event
.dwThreadId
,
1392 "UNLOAD_DLL_DEBUG_EVENT"));
1393 if (saw_create
!= 1)
1395 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1396 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1397 ourstatus
->value
.integer
= 0;
1398 retval
= main_thread_id
;
1401 case EXCEPTION_DEBUG_EVENT
:
1402 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1403 (unsigned) current_event
.dwProcessId
,
1404 (unsigned) current_event
.dwThreadId
,
1405 "EXCEPTION_DEBUG_EVENT"));
1406 if (saw_create
!= 1)
1408 switch (handle_exception (ourstatus
))
1411 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1414 retval
= current_event
.dwThreadId
;
1418 continue_status
= -1;
1423 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1424 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1425 (unsigned) current_event
.dwProcessId
,
1426 (unsigned) current_event
.dwThreadId
,
1427 "OUTPUT_DEBUG_STRING_EVENT"));
1428 if (saw_create
!= 1)
1430 retval
= handle_output_debug_string (ourstatus
);
1434 if (saw_create
!= 1)
1436 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1437 (DWORD
) current_event
.dwProcessId
,
1438 (DWORD
) current_event
.dwThreadId
);
1439 printf_unfiltered (" unknown event code %ld\n",
1440 current_event
.dwDebugEventCode
);
1444 if (!retval
|| saw_create
!= 1)
1446 if (continue_status
== -1)
1447 win32_resume (ptid
, 0, 1);
1449 CHECK (win32_continue (continue_status
, -1));
1453 inferior_ptid
= pid_to_ptid (retval
);
1454 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1461 /* Wait for interesting events to occur in the target process. */
1463 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1465 int pid
= PIDGET (ptid
);
1467 target_terminal_ours ();
1469 /* We loop when we get a non-standard exception rather than return
1470 with a SPURIOUS because resume can try and step or modify things,
1471 which needs a current_thread->h. But some of these exceptions mark
1472 the birth or death of threads, which mean that the current thread
1473 isn't necessarily what you think it is. */
1477 int retval
= get_win32_debug_event (pid
, ourstatus
);
1479 return pid_to_ptid (retval
);
1484 if (deprecated_ui_loop_hook
!= NULL
)
1485 detach
= deprecated_ui_loop_hook (0);
1488 win32_kill_inferior ();
1494 do_initial_win32_stuff (DWORD pid
)
1496 extern int stop_after_trap
;
1499 last_sig
= TARGET_SIGNAL_0
;
1501 exception_count
= 0;
1502 open_process_used
= 0;
1503 debug_registers_changed
= 0;
1504 debug_registers_used
= 0;
1505 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1508 cygwin_load_start
= cygwin_load_end
= 0;
1510 current_event
.dwProcessId
= pid
;
1511 memset (¤t_event
, 0, sizeof (current_event
));
1512 push_target (&win32_ops
);
1513 disable_breakpoints_in_shlibs ();
1514 win32_clear_solib ();
1515 clear_proceed_status ();
1516 init_wait_for_inferior ();
1518 terminal_init_inferior_with_pgrp (pid
);
1519 target_terminal_inferior ();
1523 stop_after_trap
= 1;
1524 wait_for_inferior ();
1525 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1526 resume (0, stop_signal
);
1530 stop_after_trap
= 0;
1534 /* Since Windows XP, detaching from a process is supported by Windows.
1535 The following code tries loading the appropriate functions dynamically.
1536 If loading these functions succeeds use them to actually detach from
1537 the inferior process, otherwise behave as usual, pretending that
1538 detach has worked. */
1539 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1540 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1543 has_detach_ability (void)
1545 static HMODULE kernel32
= NULL
;
1548 kernel32
= LoadLibrary ("kernel32.dll");
1551 if (!DebugSetProcessKillOnExit
)
1552 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1553 "DebugSetProcessKillOnExit");
1554 if (!DebugActiveProcessStop
)
1555 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1556 "DebugActiveProcessStop");
1557 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1563 /* Try to set or remove a user privilege to the current process. Return -1
1564 if that fails, the previous setting of that privilege otherwise.
1566 This code is copied from the Cygwin source code and rearranged to allow
1567 dynamically loading of the needed symbols from advapi32 which is only
1568 available on NT/2K/XP. */
1570 set_process_privilege (const char *privilege
, BOOL enable
)
1572 static HMODULE advapi32
= NULL
;
1573 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1574 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1575 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1576 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1578 HANDLE token_hdl
= NULL
;
1580 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1584 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1589 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1591 if (!OpenProcessToken
)
1592 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1593 if (!LookupPrivilegeValue
)
1594 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1595 "LookupPrivilegeValueA");
1596 if (!AdjustTokenPrivileges
)
1597 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1598 "AdjustTokenPrivileges");
1599 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1606 if (!OpenProcessToken (GetCurrentProcess (),
1607 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1611 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1614 new_priv
.PrivilegeCount
= 1;
1615 new_priv
.Privileges
[0].Luid
= restore_priv
;
1616 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1618 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1619 sizeof orig_priv
, &orig_priv
, &size
))
1622 /* Disabled, otherwise every `attach' in an unprivileged user session
1623 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1625 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1626 be enabled. GetLastError () returns an correct error code, though. */
1627 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1631 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1635 CloseHandle (token_hdl
);
1640 /* Attach to process PID, then initialize for debugging it. */
1642 win32_attach (char *args
, int from_tty
)
1648 error_no_arg (_("process-id to attach"));
1650 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1652 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1653 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1656 pid
= strtoul (args
, 0, 0); /* Windows pid */
1658 win32_init_thread_list ();
1659 ok
= DebugActiveProcess (pid
);
1665 /* Try fall back to Cygwin pid */
1666 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1669 ok
= DebugActiveProcess (pid
);
1674 error (_("Can't attach to process."));
1676 if (has_detach_ability ())
1677 DebugSetProcessKillOnExit (FALSE
);
1683 char *exec_file
= (char *) get_exec_file (0);
1686 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1687 target_pid_to_str (pid_to_ptid (pid
)));
1689 printf_unfiltered ("Attaching to %s\n",
1690 target_pid_to_str (pid_to_ptid (pid
)));
1692 gdb_flush (gdb_stdout
);
1695 do_initial_win32_stuff (pid
);
1696 target_terminal_ours ();
1700 win32_detach (char *args
, int from_tty
)
1704 if (has_detach_ability ())
1707 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1709 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1711 error (_("Can't detach process %lu (error %lu)"),
1712 current_event
.dwProcessId
, GetLastError ());
1715 DebugSetProcessKillOnExit (FALSE
);
1717 if (detached
&& from_tty
)
1719 char *exec_file
= get_exec_file (0);
1722 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1723 current_event
.dwProcessId
);
1724 gdb_flush (gdb_stdout
);
1726 inferior_ptid
= null_ptid
;
1727 unpush_target (&win32_ops
);
1731 win32_pid_to_exec_file (int pid
)
1733 /* Try to find the process path using the Cygwin internal process list
1734 pid isn't a valid pid, unfortunately. Use current_event.dwProcessId
1737 static char path
[MAX_PATH
+ 1];
1738 char *path_ptr
= NULL
;
1741 /* TODO: Also find native Windows processes using CW_GETPINFO_FULL. */
1743 struct external_pinfo
*pinfo
;
1745 cygwin_internal (CW_LOCK_PINFO
, 1000);
1747 (pinfo
= (struct external_pinfo
*)
1748 cygwin_internal (CW_GETPINFO
, cpid
| CW_NEXTPID
));
1751 if (pinfo
->dwProcessId
== current_event
.dwProcessId
) /* Got it */
1753 cygwin_conv_to_full_posix_path (pinfo
->progname
, path
);
1758 cygwin_internal (CW_UNLOCK_PINFO
);
1764 /* Print status information about what we're accessing. */
1767 win32_files_info (struct target_ops
*ignore
)
1769 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1770 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1774 win32_open (char *arg
, int from_tty
)
1776 error (_("Use the \"run\" command to start a Unix child process."));
1779 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1780 EXEC_FILE is the file to run.
1781 ALLARGS is a string containing the arguments to the program.
1782 ENV is the environment vector to pass. Errors reported with error(). */
1785 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1789 PROCESS_INFORMATION pi
;
1793 char real_path
[MAXPATHLEN
];
1795 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1798 int ostdin
, ostdout
, ostderr
;
1799 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1802 error (_("No executable specified, use `target exec'."));
1804 memset (&si
, 0, sizeof (si
));
1805 si
.cb
= sizeof (si
);
1810 flags
= DEBUG_ONLY_THIS_PROCESS
;
1811 cygwin_conv_to_win32_path (exec_file
, real_path
);
1817 sh
= getenv ("SHELL");
1820 cygwin_conv_to_win32_path (sh
, shell
);
1821 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1822 + strlen (allargs
) + 2);
1823 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1824 allargs
= newallargs
;
1826 flags
= DEBUG_PROCESS
;
1830 flags
= DEBUG_ONLY_THIS_PROCESS
;
1834 flags
|= CREATE_NEW_PROCESS_GROUP
;
1837 flags
|= CREATE_NEW_CONSOLE
;
1841 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1842 strcpy (args
, toexec
);
1844 strcat (args
, allargs
);
1847 /* Prepare the environment vars for CreateProcess. */
1848 cygwin_internal (CW_SYNC_WINENV
);
1850 if (!inferior_io_terminal
)
1851 tty
= ostdin
= ostdout
= ostderr
= -1;
1854 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1857 print_sys_errmsg (inferior_io_terminal
, errno
);
1858 ostdin
= ostdout
= ostderr
= -1;
1872 win32_init_thread_list ();
1873 ret
= CreateProcess (0,
1874 args
, /* command line */
1875 NULL
, /* Security */
1877 TRUE
, /* inherit handles */
1878 flags
, /* start flags */
1879 NULL
, /* environment */
1880 NULL
, /* current directory */
1898 error (_("Error creating process %s, (error %d)."),
1899 exec_file
, (unsigned) GetLastError ());
1901 if (useshell
&& shell
[0] != '\0')
1906 do_initial_win32_stuff (pi
.dwProcessId
);
1908 /* win32_continue (DBG_CONTINUE, -1); */
1912 win32_mourn_inferior (void)
1914 (void) win32_continue (DBG_CONTINUE
, -1);
1915 i386_cleanup_dregs();
1916 if (open_process_used
)
1918 CHECK (CloseHandle (current_process_handle
));
1919 open_process_used
= 0;
1921 unpush_target (&win32_ops
);
1922 generic_mourn_inferior ();
1925 /* Send a SIGINT to the process group. This acts just like the user typed a
1926 ^C on the controlling terminal. */
1931 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1932 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1933 registers_changed (); /* refresh register state */
1937 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1938 int write
, struct mem_attrib
*mem
,
1939 struct target_ops
*target
)
1944 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1945 len
, (DWORD
) (uintptr_t) memaddr
));
1946 if (!WriteProcessMemory (current_process_handle
,
1947 (LPVOID
) (uintptr_t) memaddr
, our
,
1950 FlushInstructionCache (current_process_handle
,
1951 (LPCVOID
) (uintptr_t) memaddr
, len
);
1955 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1956 len
, (DWORD
) (uintptr_t) memaddr
));
1957 if (!ReadProcessMemory (current_process_handle
,
1958 (LPCVOID
) (uintptr_t) memaddr
, our
,
1966 win32_kill_inferior (void)
1968 CHECK (TerminateProcess (current_process_handle
, 0));
1972 if (!win32_continue (DBG_CONTINUE
, -1))
1974 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1976 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1980 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1984 win32_prepare_to_store (struct regcache
*regcache
)
1986 /* Do nothing, since we can store individual regs */
1990 win32_can_run (void)
1998 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1999 PIDGET (inferior_ptid
)));
2002 /* Convert pid to printable format. */
2004 win32_pid_to_str (ptid_t ptid
)
2006 static char buf
[80];
2007 int pid
= PIDGET (ptid
);
2009 if ((DWORD
) pid
== current_event
.dwProcessId
)
2010 sprintf (buf
, "process %d", pid
);
2012 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2017 win32_xfer_shared_libraries (struct target_ops
*ops
,
2018 enum target_object object
, const char *annex
,
2019 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2020 ULONGEST offset
, LONGEST len
)
2022 struct obstack obstack
;
2030 obstack_init (&obstack
);
2031 obstack_grow_str (&obstack
, "<library-list>\n");
2032 for (so
= solib_start
.next
; so
; so
= so
->next
)
2033 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2034 obstack_grow_str0 (&obstack
, "</library-list>\n");
2036 buf
= obstack_finish (&obstack
);
2037 len_avail
= strlen (buf
);
2038 if (offset
>= len_avail
)
2041 if (len
> len_avail
- offset
)
2042 len
= len_avail
- offset
;
2043 memcpy (readbuf
, buf
+ offset
, len
);
2045 obstack_free (&obstack
, NULL
);
2050 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2051 const char *annex
, gdb_byte
*readbuf
,
2052 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2056 case TARGET_OBJECT_MEMORY
:
2058 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2059 len
, 0/*write*/, NULL
, ops
);
2061 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2062 len
, 1/*write*/, NULL
, ops
);
2065 case TARGET_OBJECT_LIBRARIES
:
2066 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2067 writebuf
, offset
, len
);
2070 if (ops
->beneath
!= NULL
)
2071 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2072 readbuf
, writebuf
, offset
, len
);
2078 init_win32_ops (void)
2080 win32_ops
.to_shortname
= "child";
2081 win32_ops
.to_longname
= "Win32 child process";
2082 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2083 win32_ops
.to_open
= win32_open
;
2084 win32_ops
.to_close
= win32_close
;
2085 win32_ops
.to_attach
= win32_attach
;
2086 win32_ops
.to_detach
= win32_detach
;
2087 win32_ops
.to_resume
= win32_resume
;
2088 win32_ops
.to_wait
= win32_wait
;
2089 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2090 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2091 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2092 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2093 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2094 win32_ops
.to_files_info
= win32_files_info
;
2095 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2096 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2097 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2098 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2099 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2100 win32_ops
.to_terminal_ours
= terminal_ours
;
2101 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2102 win32_ops
.to_terminal_info
= child_terminal_info
;
2103 win32_ops
.to_kill
= win32_kill_inferior
;
2104 win32_ops
.to_create_inferior
= win32_create_inferior
;
2105 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2106 win32_ops
.to_can_run
= win32_can_run
;
2107 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2108 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2109 win32_ops
.to_stop
= win32_stop
;
2110 win32_ops
.to_stratum
= process_stratum
;
2111 win32_ops
.to_has_all_memory
= 1;
2112 win32_ops
.to_has_memory
= 1;
2113 win32_ops
.to_has_stack
= 1;
2114 win32_ops
.to_has_registers
= 1;
2115 win32_ops
.to_has_execution
= 1;
2116 win32_ops
.to_magic
= OPS_MAGIC
;
2117 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2121 set_win32_aliases (char *argv0
)
2123 add_info_alias ("dll", "sharedlibrary", 1);
2127 _initialize_win32_nat (void)
2129 struct cmd_list_element
*c
;
2133 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2134 _("Load dll library symbols from FILE."));
2135 set_cmd_completer (c
, filename_completer
);
2137 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2140 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2141 Set use of shell to start subprocess."), _("\
2142 Show use of shell to start subprocess."), NULL
,
2144 NULL
, /* FIXME: i18n: */
2145 &setlist
, &showlist
);
2147 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2148 Break when an exception is detected in the Cygwin DLL itself."), _("\
2149 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2151 NULL
, /* FIXME: i18n: */
2152 &setlist
, &showlist
);
2155 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2156 Set creation of new console when creating child process."), _("\
2157 Show creation of new console when creating child process."), NULL
,
2159 NULL
, /* FIXME: i18n: */
2160 &setlist
, &showlist
);
2162 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2163 Set creation of new group when creating child process."), _("\
2164 Show creation of new group when creating child process."), NULL
,
2166 NULL
, /* FIXME: i18n: */
2167 &setlist
, &showlist
);
2169 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2170 Set whether to display execution in child process."), _("\
2171 Show whether to display execution in child process."), NULL
,
2173 NULL
, /* FIXME: i18n: */
2174 &setlist
, &showlist
);
2176 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2177 Set whether to display kernel events in child process."), _("\
2178 Show whether to display kernel events in child process."), NULL
,
2180 NULL
, /* FIXME: i18n: */
2181 &setlist
, &showlist
);
2183 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2184 Set whether to display memory accesses in child process."), _("\
2185 Show whether to display memory accesses in child process."), NULL
,
2187 NULL
, /* FIXME: i18n: */
2188 &setlist
, &showlist
);
2190 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2191 &debug_exceptions
, _("\
2192 Set whether to display kernel exceptions in child process."), _("\
2193 Show whether to display kernel exceptions in child process."), NULL
,
2195 NULL
, /* FIXME: i18n: */
2196 &setlist
, &showlist
);
2198 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2199 _("Print information specific to Win32 debugging."),
2200 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2202 add_cmd ("selector", class_info
, display_selectors
,
2203 _("Display selectors infos."),
2205 add_target (&win32_ops
);
2206 deprecated_init_ui_hook
= set_win32_aliases
;
2209 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2211 /* Pass the address ADDR to the inferior in the I'th debug register.
2212 Here we just store the address in dr array, the registers will be
2213 actually set up when win32_continue is called. */
2215 cygwin_set_dr (int i
, CORE_ADDR addr
)
2218 internal_error (__FILE__
, __LINE__
,
2219 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2220 dr
[i
] = (unsigned) addr
;
2221 debug_registers_changed
= 1;
2222 debug_registers_used
= 1;
2225 /* Pass the value VAL to the inferior in the DR7 debug control
2226 register. Here we just store the address in D_REGS, the watchpoint
2227 will be actually set up in win32_wait. */
2229 cygwin_set_dr7 (unsigned val
)
2232 debug_registers_changed
= 1;
2233 debug_registers_used
= 1;
2236 /* Get the value of the DR6 debug status register from the inferior.
2237 Here we just return the value stored in dr[6]
2238 by the last call to thread_rec for current_event.dwThreadId id. */
2240 cygwin_get_dr6 (void)
2245 /* Determine if the thread referenced by "pid" is alive
2246 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2247 it means that the pid has died. Otherwise it is assumed to be alive. */
2249 win32_win32_thread_alive (ptid_t ptid
)
2251 int pid
= PIDGET (ptid
);
2253 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2258 _initialize_check_for_gdb_ini (void)
2261 if (inhibit_gdbinit
)
2264 homedir
= getenv ("HOME");
2268 char *oldini
= (char *) alloca (strlen (homedir
) +
2269 sizeof ("/gdb.ini"));
2270 strcpy (oldini
, homedir
);
2271 p
= strchr (oldini
, '\0');
2272 if (p
> oldini
&& p
[-1] != '/')
2274 strcpy (p
, "gdb.ini");
2275 if (access (oldini
, 0) == 0)
2277 int len
= strlen (oldini
);
2278 char *newini
= alloca (len
+ 1);
2279 sprintf (newini
, "%.*s.gdbinit",
2280 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2281 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);