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 dr
[0] = th
->context
.Dr0
;
387 dr
[1] = th
->context
.Dr1
;
388 dr
[2] = th
->context
.Dr2
;
389 dr
[3] = th
->context
.Dr3
;
390 dr
[6] = th
->context
.Dr6
;
391 dr
[7] = th
->context
.Dr7
;
393 current_thread
->reload_context
= 0;
396 #define I387_ST0_REGNUM I386_ST0_REGNUM
398 if (r
== I387_FISEG_REGNUM
)
400 l
= *((long *) context_offset
) & 0xffff;
401 regcache_raw_supply (regcache
, r
, (char *) &l
);
403 else if (r
== I387_FOP_REGNUM
)
405 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
406 regcache_raw_supply (regcache
, r
, (char *) &l
);
409 regcache_raw_supply (regcache
, r
, context_offset
);
412 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
413 do_win32_fetch_inferior_registers (regcache
, r
);
416 #undef I387_ST0_REGNUM
420 win32_fetch_inferior_registers (struct regcache
*regcache
, int r
)
422 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
423 /* Check if current_thread exists. Windows sometimes uses a non-existent
424 thread id in its events */
426 do_win32_fetch_inferior_registers (regcache
, r
);
430 do_win32_store_inferior_registers (const struct regcache
*regcache
, int r
)
433 /* Windows sometimes uses a non-existent thread id in its events */;
435 regcache_raw_collect (regcache
, r
,
436 ((char *) ¤t_thread
->context
) + mappings
[r
]);
439 for (r
= 0; r
< gdbarch_num_regs (get_regcache_arch (regcache
)); r
++)
440 do_win32_store_inferior_registers (regcache
, r
);
444 /* Store a new register value into the current thread context */
446 win32_store_inferior_registers (struct regcache
*regcache
, int r
)
448 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
449 /* Check if current_thread exists. Windows sometimes uses a non-existent
450 thread id in its events */
452 do_win32_store_inferior_registers (regcache
, r
);
455 static int psapi_loaded
= 0;
456 static HMODULE psapi_module_handle
= NULL
;
457 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
458 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
459 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
462 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
468 HMODULE
*DllHandle
= dh_buf
;
473 psapi_EnumProcessModules
== NULL
||
474 psapi_GetModuleInformation
== NULL
||
475 psapi_GetModuleFileNameExA
== NULL
)
480 psapi_module_handle
= LoadLibrary ("psapi.dll");
481 if (!psapi_module_handle
)
483 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
486 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
487 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
488 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
489 "GetModuleFileNameExA");
490 if (psapi_EnumProcessModules
== NULL
||
491 psapi_GetModuleInformation
== NULL
||
492 psapi_GetModuleFileNameExA
== NULL
)
497 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
502 if (!ok
|| !cbNeeded
)
505 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
509 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
516 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
518 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
522 error (_("Can't get module info"));
524 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
529 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
531 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
536 dll_name_ret
[0] = '\0';
540 /* Encapsulate the information required in a call to
541 symbol_file_add_args */
542 struct safe_symbol_file_add_args
546 struct section_addr_info
*addrs
;
549 struct ui_file
*err
, *out
;
553 /* Maintain a linked list of "so" information. */
559 static struct so_list solib_start
, *solib_end
;
561 /* Call symbol_file_add with stderr redirected. We don't care if there
564 safe_symbol_file_add_stub (void *argv
)
566 #define p ((struct safe_symbol_file_add_args *) argv)
567 struct so_list
*so
= &solib_start
;
569 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
574 /* Restore gdb's stderr after calling symbol_file_add */
576 safe_symbol_file_add_cleanup (void *p
)
578 #define sp ((struct safe_symbol_file_add_args *)p)
579 gdb_flush (gdb_stderr
);
580 gdb_flush (gdb_stdout
);
581 ui_file_delete (gdb_stderr
);
582 ui_file_delete (gdb_stdout
);
583 gdb_stderr
= sp
->err
;
584 gdb_stdout
= sp
->out
;
588 /* symbol_file_add wrapper that prevents errors from being displayed. */
589 static struct objfile
*
590 safe_symbol_file_add (char *name
, int from_tty
,
591 struct section_addr_info
*addrs
,
592 int mainline
, int flags
)
594 struct safe_symbol_file_add_args p
;
595 struct cleanup
*cleanup
;
597 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
601 gdb_flush (gdb_stderr
);
602 gdb_flush (gdb_stdout
);
603 gdb_stderr
= ui_file_new ();
604 gdb_stdout
= ui_file_new ();
606 p
.from_tty
= from_tty
;
608 p
.mainline
= mainline
;
610 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
612 do_cleanups (cleanup
);
616 static struct so_list
*
617 win32_make_so (const char *name
, DWORD load_addr
)
620 char buf
[MAX_PATH
+ 1];
621 char cwd
[MAX_PATH
+ 1];
623 WIN32_FIND_DATA w32_fd
;
624 HANDLE h
= FindFirstFile(name
, &w32_fd
);
625 MEMORY_BASIC_INFORMATION m
;
627 if (h
== INVALID_HANDLE_VALUE
)
633 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
635 p
= strrchr (buf
, '\\');
638 SetCurrentDirectory (buf
);
639 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
640 SetCurrentDirectory (cwd
);
644 if (strcasecmp (buf
, "ntdll.dll") == 0)
646 GetSystemDirectory (buf
, sizeof (buf
));
647 strcat (buf
, "\\ntdll.dll");
649 so
= XZALLOC (struct so_list
);
650 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
651 so
->lm_info
->load_addr
= load_addr
;
652 strcpy (so
->so_original_name
, name
);
654 strcpy (so
->so_name
, buf
);
656 cygwin_conv_to_posix_path (buf
, so
->so_name
);
657 /* Record cygwin1.dll .text start/end. */
658 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
659 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
662 asection
*text
= NULL
;
665 abfd
= bfd_openr (name
, "pei-i386");
670 if (bfd_check_format (abfd
, bfd_object
))
671 text
= bfd_get_section_by_name (abfd
, ".text");
679 /* The symbols in a dll are offset by 0x1000, which is the the
680 offset from 0 of the first byte in an image - because of the
681 file header and the section alignment. */
682 cygwin_load_start
= load_addr
+ 0x1000;
683 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
693 get_image_name (HANDLE h
, void *address
, int unicode
)
695 static char buf
[(2 * MAX_PATH
) + 1];
696 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
702 /* Attempt to read the name of the dll that was detected.
703 This is documented to work only when actively debugging
704 a program. It will not work for attached processes. */
708 /* See if we could read the address of a string, and that the
709 address isn't null. */
710 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
711 || done
!= sizeof (address_ptr
) || !address_ptr
)
714 /* Find the length of the string */
715 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
716 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
720 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
723 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
724 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
727 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
733 /* Wait for child to do something. Return pid of child, or -1 in case
734 of error; store status through argument pointer OURSTATUS. */
736 handle_load_dll (void *dummy
)
738 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
739 char dll_buf
[MAX_PATH
+ 1];
740 char *dll_name
= NULL
;
742 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
744 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
745 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
749 if (*dll_name
== '\0')
750 dll_name
= get_image_name (current_process_handle
,
751 event
->lpImageName
, event
->fUnicode
);
755 solib_end
->next
= win32_make_so (dll_name
, (DWORD
) event
->lpBaseOfDll
);
756 solib_end
= solib_end
->next
;
762 win32_free_so (struct so_list
*so
)
770 handle_unload_dll (void *dummy
)
772 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
;
775 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
776 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
778 struct so_list
*sodel
= so
->next
;
779 so
->next
= sodel
->next
;
782 win32_free_so (sodel
);
783 solib_add (NULL
, 0, NULL
, auto_solib_add
);
787 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
792 /* Clear list of loaded DLLs. */
794 win32_clear_solib (void)
796 solib_start
.next
= NULL
;
797 solib_end
= &solib_start
;
800 /* Load DLL symbol info. */
802 dll_symbol_command (char *args
, int from_tty
)
808 error (_("dll-symbols requires a file name"));
811 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
813 char *newargs
= (char *) alloca (n
+ 4 + 1);
814 strcpy (newargs
, args
);
815 strcat (newargs
, ".dll");
819 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
822 /* Handle DEBUG_STRING output from child process.
823 Cygwin prepends its messages with a "cygwin:". Interpret this as
824 a Cygwin signal. Otherwise just print the string as a warning. */
826 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
831 if (!target_read_string
832 ((CORE_ADDR
) (uintptr_t) current_event
.u
.DebugString
.lpDebugStringData
,
836 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
839 if (strncmp (s
, "cYg", 3) != 0)
843 #ifdef __COPY_CONTEXT_SIZE
846 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
847 itself and then optionally followed by the thread id and address to saved context
848 within the DLL. If these are supplied, then the given thread is assumed to have
849 issued the signal and the context from the thread is assumed to be stored at the
850 given address in the inferior. Tell gdb to treat this like a real signal. */
852 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
853 int gotasig
= target_signal_from_host (sig
);
854 ourstatus
->value
.sig
= gotasig
;
859 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
860 retval
= strtoul (p
, &p
, 0);
862 retval
= main_thread_id
;
863 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
864 && ReadProcessMemory (current_process_handle
, x
,
865 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
866 && n
== __COPY_CONTEXT_SIZE
)
867 have_saved_context
= 1;
868 current_event
.dwThreadId
= retval
;
879 display_selector (HANDLE thread
, DWORD sel
)
882 if (GetThreadSelectorEntry (thread
, sel
, &info
))
885 printf_filtered ("0x%03lx: ", sel
);
886 if (!info
.HighWord
.Bits
.Pres
)
888 puts_filtered ("Segment not present\n");
891 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
892 (info
.HighWord
.Bits
.BaseMid
<< 16)
894 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
895 if (info
.HighWord
.Bits
.Granularity
)
896 limit
= (limit
<< 12) | 0xfff;
897 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
898 if (info
.HighWord
.Bits
.Default_Big
)
899 puts_filtered(" 32-bit ");
901 puts_filtered(" 16-bit ");
902 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
905 puts_filtered ("Data (Read-Only, Exp-up");
908 puts_filtered ("Data (Read/Write, Exp-up");
911 puts_filtered ("Unused segment (");
914 puts_filtered ("Data (Read/Write, Exp-down");
917 puts_filtered ("Code (Exec-Only, N.Conf");
920 puts_filtered ("Code (Exec/Read, N.Conf");
923 puts_filtered ("Code (Exec-Only, Conf");
926 puts_filtered ("Code (Exec/Read, Conf");
929 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
931 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
932 puts_filtered(", N.Acc");
933 puts_filtered (")\n");
934 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
935 puts_filtered("System selector ");
936 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
937 if (info
.HighWord
.Bits
.Granularity
)
938 puts_filtered ("Page granular.\n");
940 puts_filtered ("Byte granular.\n");
945 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
951 display_selectors (char * args
, int from_tty
)
955 puts_filtered ("Impossible to display selectors now.\n");
961 puts_filtered ("Selector $cs\n");
962 display_selector (current_thread
->h
,
963 current_thread
->context
.SegCs
);
964 puts_filtered ("Selector $ds\n");
965 display_selector (current_thread
->h
,
966 current_thread
->context
.SegDs
);
967 puts_filtered ("Selector $es\n");
968 display_selector (current_thread
->h
,
969 current_thread
->context
.SegEs
);
970 puts_filtered ("Selector $ss\n");
971 display_selector (current_thread
->h
,
972 current_thread
->context
.SegSs
);
973 puts_filtered ("Selector $fs\n");
974 display_selector (current_thread
->h
,
975 current_thread
->context
.SegFs
);
976 puts_filtered ("Selector $gs\n");
977 display_selector (current_thread
->h
,
978 current_thread
->context
.SegGs
);
983 sel
= parse_and_eval_long (args
);
984 printf_filtered ("Selector \"%s\"\n",args
);
985 display_selector (current_thread
->h
, sel
);
989 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
992 info_w32_command (char *args
, int from_tty
)
994 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
998 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
999 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1000 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1003 handle_exception (struct target_waitstatus
*ourstatus
)
1006 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1008 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1010 /* Record the context of the current thread */
1011 th
= thread_rec (current_event
.dwThreadId
, -1);
1015 case EXCEPTION_ACCESS_VIOLATION
:
1016 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1017 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1020 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1021 a kind of exception handling to deal with passed-in invalid addresses. gdb
1022 should not treat these as real SEGVs since they will be silently handled by
1023 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1024 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1025 within the text segment of the DLL itself. */
1027 bfd_vma addr
= (bfd_vma
) (uintptr_t) current_event
.u
.Exception
.
1028 ExceptionRecord
.ExceptionAddress
;
1029 if ((!cygwin_exceptions
&& (addr
>= cygwin_load_start
&& addr
< cygwin_load_end
))
1030 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1031 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1036 case STATUS_STACK_OVERFLOW
:
1037 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1038 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1040 case STATUS_FLOAT_DENORMAL_OPERAND
:
1041 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1042 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1044 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1045 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1046 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1048 case STATUS_FLOAT_INEXACT_RESULT
:
1049 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1050 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1052 case STATUS_FLOAT_INVALID_OPERATION
:
1053 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1054 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1056 case STATUS_FLOAT_OVERFLOW
:
1057 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1058 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1060 case STATUS_FLOAT_STACK_CHECK
:
1061 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1062 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1064 case STATUS_FLOAT_UNDERFLOW
:
1065 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1066 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1068 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1069 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1070 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1072 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1073 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1074 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1076 case STATUS_INTEGER_OVERFLOW
:
1077 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1078 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1080 case EXCEPTION_BREAKPOINT
:
1081 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1082 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1085 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1086 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1088 case DBG_CONTROL_BREAK
:
1089 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1090 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1092 case EXCEPTION_SINGLE_STEP
:
1093 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1094 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1096 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1097 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1098 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1100 case EXCEPTION_PRIV_INSTRUCTION
:
1101 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1102 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1104 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1105 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1106 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1109 /* Treat unhandled first chance exceptions specially. */
1110 if (current_event
.u
.Exception
.dwFirstChance
)
1112 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1113 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1114 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1115 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1119 last_sig
= ourstatus
->value
.sig
;
1123 /* Resume all artificially suspended threads if we are continuing
1126 win32_continue (DWORD continue_status
, int id
)
1132 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1133 current_event
.dwProcessId
, current_event
.dwThreadId
,
1134 continue_status
== DBG_CONTINUE
?
1135 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1137 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1138 if ((id
== -1 || id
== (int) th
->id
)
1141 if (debug_registers_changed
)
1143 th
->context
.ContextFlags
|= CONTEXT_DEBUG_REGISTERS
;
1144 th
->context
.Dr0
= dr
[0];
1145 th
->context
.Dr1
= dr
[1];
1146 th
->context
.Dr2
= dr
[2];
1147 th
->context
.Dr3
= dr
[3];
1148 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1149 th
->context
.Dr7
= dr
[7];
1151 if (th
->context
.ContextFlags
)
1153 CHECK (SetThreadContext (th
->h
, &th
->context
));
1154 th
->context
.ContextFlags
= 0;
1156 if (th
->suspended
> 0)
1157 (void) ResumeThread (th
->h
);
1161 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1162 current_event
.dwThreadId
,
1165 debug_registers_changed
= 0;
1169 /* Called in pathological case where Windows fails to send a
1170 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1172 fake_create_process (void)
1174 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1175 current_event
.dwProcessId
);
1176 if (current_process_handle
!= NULL
)
1177 open_process_used
= 1;
1180 error (_("OpenProcess call failed, GetLastError = %lud\n"),
1182 /* We can not debug anything in that case. */
1184 main_thread_id
= current_event
.dwThreadId
;
1185 current_thread
= win32_add_thread (main_thread_id
,
1186 current_event
.u
.CreateThread
.hThread
);
1187 return main_thread_id
;
1191 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1194 DWORD continue_status
= DBG_CONTINUE
;
1196 int pid
= PIDGET (ptid
);
1198 if (sig
!= TARGET_SIGNAL_0
)
1200 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1202 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1204 else if (sig
== last_sig
)
1205 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1208 /* This code does not seem to work, because
1209 the kernel does probably not consider changes in the ExceptionRecord
1210 structure when passing the exception to the inferior.
1211 Note that this seems possible in the exception handler itself. */
1214 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1215 if (xlate
[i
].us
== sig
)
1217 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1219 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1222 if (continue_status
== DBG_CONTINUE
)
1224 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1228 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1232 last_sig
= TARGET_SIGNAL_0
;
1234 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1237 /* Get context for currently selected thread */
1238 th
= thread_rec (PIDGET (inferior_ptid
), FALSE
);
1243 /* Single step by setting t bit */
1244 win32_fetch_inferior_registers (get_current_regcache (),
1245 gdbarch_ps_regnum (current_gdbarch
));
1246 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1249 if (th
->context
.ContextFlags
)
1251 if (debug_registers_changed
)
1253 th
->context
.Dr0
= dr
[0];
1254 th
->context
.Dr1
= dr
[1];
1255 th
->context
.Dr2
= dr
[2];
1256 th
->context
.Dr3
= dr
[3];
1257 th
->context
.Dr6
= DR6_CLEAR_VALUE
;
1258 th
->context
.Dr7
= dr
[7];
1260 CHECK (SetThreadContext (th
->h
, &th
->context
));
1261 th
->context
.ContextFlags
= 0;
1265 /* Allow continuing with the same signal that interrupted us.
1266 Otherwise complain. */
1268 win32_continue (continue_status
, pid
);
1271 /* Get the next event from the child. Return 1 if the event requires
1272 handling by WFI (or whatever).
1275 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1278 DWORD continue_status
, event_code
;
1280 static thread_info dummy_thread_info
;
1284 last_sig
= TARGET_SIGNAL_0
;
1286 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1290 continue_status
= DBG_CONTINUE
;
1292 event_code
= current_event
.dwDebugEventCode
;
1293 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1295 have_saved_context
= 0;
1299 case CREATE_THREAD_DEBUG_EVENT
:
1300 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1301 (unsigned) current_event
.dwProcessId
,
1302 (unsigned) current_event
.dwThreadId
,
1303 "CREATE_THREAD_DEBUG_EVENT"));
1304 if (saw_create
!= 1)
1306 if (!saw_create
&& attach_flag
)
1308 /* Kludge around a Windows bug where first event is a create
1309 thread event. Caused when attached process does not have
1311 retval
= ourstatus
->value
.related_pid
= fake_create_process ();
1317 /* Record the existence of this thread */
1318 th
= win32_add_thread (current_event
.dwThreadId
,
1319 current_event
.u
.CreateThread
.hThread
);
1321 printf_unfiltered ("[New %s]\n",
1323 pid_to_ptid (current_event
.dwThreadId
)));
1324 retval
= current_event
.dwThreadId
;
1327 case EXIT_THREAD_DEBUG_EVENT
:
1328 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1329 (unsigned) current_event
.dwProcessId
,
1330 (unsigned) current_event
.dwThreadId
,
1331 "EXIT_THREAD_DEBUG_EVENT"));
1332 if (current_event
.dwThreadId
!= main_thread_id
)
1334 win32_delete_thread (current_event
.dwThreadId
);
1335 th
= &dummy_thread_info
;
1339 case CREATE_PROCESS_DEBUG_EVENT
:
1340 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1341 (unsigned) current_event
.dwProcessId
,
1342 (unsigned) current_event
.dwThreadId
,
1343 "CREATE_PROCESS_DEBUG_EVENT"));
1344 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1345 if (++saw_create
!= 1)
1348 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1350 win32_delete_thread (main_thread_id
);
1351 main_thread_id
= current_event
.dwThreadId
;
1352 /* Add the main thread */
1353 th
= win32_add_thread (main_thread_id
,
1354 current_event
.u
.CreateProcessInfo
.hThread
);
1355 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1358 case EXIT_PROCESS_DEBUG_EVENT
:
1359 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1360 (unsigned) current_event
.dwProcessId
,
1361 (unsigned) current_event
.dwThreadId
,
1362 "EXIT_PROCESS_DEBUG_EVENT"));
1363 if (saw_create
!= 1)
1365 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1366 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1367 retval
= main_thread_id
;
1370 case LOAD_DLL_DEBUG_EVENT
:
1371 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1372 (unsigned) current_event
.dwProcessId
,
1373 (unsigned) current_event
.dwThreadId
,
1374 "LOAD_DLL_DEBUG_EVENT"));
1375 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1376 if (saw_create
!= 1)
1378 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1379 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1380 ourstatus
->value
.integer
= 0;
1381 retval
= main_thread_id
;
1384 case UNLOAD_DLL_DEBUG_EVENT
:
1385 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1386 (unsigned) current_event
.dwProcessId
,
1387 (unsigned) current_event
.dwThreadId
,
1388 "UNLOAD_DLL_DEBUG_EVENT"));
1389 if (saw_create
!= 1)
1391 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1392 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1393 ourstatus
->value
.integer
= 0;
1394 retval
= main_thread_id
;
1397 case EXCEPTION_DEBUG_EVENT
:
1398 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1399 (unsigned) current_event
.dwProcessId
,
1400 (unsigned) current_event
.dwThreadId
,
1401 "EXCEPTION_DEBUG_EVENT"));
1402 if (saw_create
!= 1)
1404 switch (handle_exception (ourstatus
))
1407 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1410 retval
= current_event
.dwThreadId
;
1414 continue_status
= -1;
1419 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1420 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1421 (unsigned) current_event
.dwProcessId
,
1422 (unsigned) current_event
.dwThreadId
,
1423 "OUTPUT_DEBUG_STRING_EVENT"));
1424 if (saw_create
!= 1)
1426 retval
= handle_output_debug_string (ourstatus
);
1430 if (saw_create
!= 1)
1432 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1433 (DWORD
) current_event
.dwProcessId
,
1434 (DWORD
) current_event
.dwThreadId
);
1435 printf_unfiltered (" unknown event code %ld\n",
1436 current_event
.dwDebugEventCode
);
1440 if (!retval
|| saw_create
!= 1)
1442 if (continue_status
== -1)
1443 win32_resume (ptid
, 0, 1);
1445 CHECK (win32_continue (continue_status
, -1));
1449 inferior_ptid
= pid_to_ptid (retval
);
1450 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1457 /* Wait for interesting events to occur in the target process. */
1459 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1461 int pid
= PIDGET (ptid
);
1463 target_terminal_ours ();
1465 /* We loop when we get a non-standard exception rather than return
1466 with a SPURIOUS because resume can try and step or modify things,
1467 which needs a current_thread->h. But some of these exceptions mark
1468 the birth or death of threads, which mean that the current thread
1469 isn't necessarily what you think it is. */
1473 int retval
= get_win32_debug_event (pid
, ourstatus
);
1475 return pid_to_ptid (retval
);
1480 if (deprecated_ui_loop_hook
!= NULL
)
1481 detach
= deprecated_ui_loop_hook (0);
1484 win32_kill_inferior ();
1490 do_initial_win32_stuff (DWORD pid
)
1492 extern int stop_after_trap
;
1495 last_sig
= TARGET_SIGNAL_0
;
1497 exception_count
= 0;
1498 open_process_used
= 0;
1499 debug_registers_changed
= 0;
1500 debug_registers_used
= 0;
1501 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1504 cygwin_load_start
= cygwin_load_end
= 0;
1506 current_event
.dwProcessId
= pid
;
1507 memset (¤t_event
, 0, sizeof (current_event
));
1508 push_target (&win32_ops
);
1509 disable_breakpoints_in_shlibs ();
1510 win32_clear_solib ();
1511 clear_proceed_status ();
1512 init_wait_for_inferior ();
1514 terminal_init_inferior_with_pgrp (pid
);
1515 target_terminal_inferior ();
1519 stop_after_trap
= 1;
1520 wait_for_inferior ();
1521 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1522 resume (0, stop_signal
);
1526 stop_after_trap
= 0;
1530 /* Since Windows XP, detaching from a process is supported by Windows.
1531 The following code tries loading the appropriate functions dynamically.
1532 If loading these functions succeeds use them to actually detach from
1533 the inferior process, otherwise behave as usual, pretending that
1534 detach has worked. */
1535 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1536 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1539 has_detach_ability (void)
1541 static HMODULE kernel32
= NULL
;
1544 kernel32
= LoadLibrary ("kernel32.dll");
1547 if (!DebugSetProcessKillOnExit
)
1548 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1549 "DebugSetProcessKillOnExit");
1550 if (!DebugActiveProcessStop
)
1551 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1552 "DebugActiveProcessStop");
1553 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1559 /* Try to set or remove a user privilege to the current process. Return -1
1560 if that fails, the previous setting of that privilege otherwise.
1562 This code is copied from the Cygwin source code and rearranged to allow
1563 dynamically loading of the needed symbols from advapi32 which is only
1564 available on NT/2K/XP. */
1566 set_process_privilege (const char *privilege
, BOOL enable
)
1568 static HMODULE advapi32
= NULL
;
1569 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1570 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1571 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1572 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1574 HANDLE token_hdl
= NULL
;
1576 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1580 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1585 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1587 if (!OpenProcessToken
)
1588 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1589 if (!LookupPrivilegeValue
)
1590 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1591 "LookupPrivilegeValueA");
1592 if (!AdjustTokenPrivileges
)
1593 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1594 "AdjustTokenPrivileges");
1595 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1602 if (!OpenProcessToken (GetCurrentProcess (),
1603 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1607 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1610 new_priv
.PrivilegeCount
= 1;
1611 new_priv
.Privileges
[0].Luid
= restore_priv
;
1612 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1614 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1615 sizeof orig_priv
, &orig_priv
, &size
))
1618 /* Disabled, otherwise every `attach' in an unprivileged user session
1619 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1621 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1622 be enabled. GetLastError () returns an correct error code, though. */
1623 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1627 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1631 CloseHandle (token_hdl
);
1636 /* Attach to process PID, then initialize for debugging it. */
1638 win32_attach (char *args
, int from_tty
)
1644 error_no_arg (_("process-id to attach"));
1646 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1648 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1649 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1652 pid
= strtoul (args
, 0, 0); /* Windows pid */
1654 win32_init_thread_list ();
1655 ok
= DebugActiveProcess (pid
);
1661 /* Try fall back to Cygwin pid */
1662 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1665 ok
= DebugActiveProcess (pid
);
1670 error (_("Can't attach to process."));
1672 if (has_detach_ability ())
1673 DebugSetProcessKillOnExit (FALSE
);
1679 char *exec_file
= (char *) get_exec_file (0);
1682 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1683 target_pid_to_str (pid_to_ptid (pid
)));
1685 printf_unfiltered ("Attaching to %s\n",
1686 target_pid_to_str (pid_to_ptid (pid
)));
1688 gdb_flush (gdb_stdout
);
1691 do_initial_win32_stuff (pid
);
1692 target_terminal_ours ();
1696 win32_detach (char *args
, int from_tty
)
1700 if (has_detach_ability ())
1703 win32_resume (ptid
, 0, TARGET_SIGNAL_0
);
1705 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1707 error (_("Can't detach process %lu (error %lu)"),
1708 current_event
.dwProcessId
, GetLastError ());
1711 DebugSetProcessKillOnExit (FALSE
);
1713 if (detached
&& from_tty
)
1715 char *exec_file
= get_exec_file (0);
1718 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1719 current_event
.dwProcessId
);
1720 gdb_flush (gdb_stdout
);
1722 inferior_ptid
= null_ptid
;
1723 unpush_target (&win32_ops
);
1727 win32_pid_to_exec_file (int pid
)
1729 /* Try to find the process path using the Cygwin internal process list
1730 pid isn't a valid pid, unfortunately. Use current_event.dwProcessId
1733 static char path
[MAX_PATH
+ 1];
1734 char *path_ptr
= NULL
;
1737 /* TODO: Also find native Windows processes using CW_GETPINFO_FULL. */
1739 struct external_pinfo
*pinfo
;
1741 cygwin_internal (CW_LOCK_PINFO
, 1000);
1743 (pinfo
= (struct external_pinfo
*)
1744 cygwin_internal (CW_GETPINFO
, cpid
| CW_NEXTPID
));
1747 if (pinfo
->dwProcessId
== current_event
.dwProcessId
) /* Got it */
1749 cygwin_conv_to_full_posix_path (pinfo
->progname
, path
);
1754 cygwin_internal (CW_UNLOCK_PINFO
);
1760 /* Print status information about what we're accessing. */
1763 win32_files_info (struct target_ops
*ignore
)
1765 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1766 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1770 win32_open (char *arg
, int from_tty
)
1772 error (_("Use the \"run\" command to start a Unix child process."));
1775 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1776 EXEC_FILE is the file to run.
1777 ALLARGS is a string containing the arguments to the program.
1778 ENV is the environment vector to pass. Errors reported with error(). */
1781 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1785 PROCESS_INFORMATION pi
;
1789 char real_path
[MAXPATHLEN
];
1791 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1794 int ostdin
, ostdout
, ostderr
;
1795 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1798 error (_("No executable specified, use `target exec'."));
1800 memset (&si
, 0, sizeof (si
));
1801 si
.cb
= sizeof (si
);
1806 flags
= DEBUG_ONLY_THIS_PROCESS
;
1807 cygwin_conv_to_win32_path (exec_file
, real_path
);
1813 sh
= getenv ("SHELL");
1816 cygwin_conv_to_win32_path (sh
, shell
);
1817 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1818 + strlen (allargs
) + 2);
1819 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1820 allargs
= newallargs
;
1822 flags
= DEBUG_PROCESS
;
1826 flags
= DEBUG_ONLY_THIS_PROCESS
;
1830 flags
|= CREATE_NEW_PROCESS_GROUP
;
1833 flags
|= CREATE_NEW_CONSOLE
;
1837 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1838 strcpy (args
, toexec
);
1840 strcat (args
, allargs
);
1843 /* Prepare the environment vars for CreateProcess. */
1844 cygwin_internal (CW_SYNC_WINENV
);
1846 if (!inferior_io_terminal
)
1847 tty
= ostdin
= ostdout
= ostderr
= -1;
1850 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1853 print_sys_errmsg (inferior_io_terminal
, errno
);
1854 ostdin
= ostdout
= ostderr
= -1;
1868 win32_init_thread_list ();
1869 ret
= CreateProcess (0,
1870 args
, /* command line */
1871 NULL
, /* Security */
1873 TRUE
, /* inherit handles */
1874 flags
, /* start flags */
1875 NULL
, /* environment */
1876 NULL
, /* current directory */
1894 error (_("Error creating process %s, (error %d)."),
1895 exec_file
, (unsigned) GetLastError ());
1897 if (useshell
&& shell
[0] != '\0')
1902 do_initial_win32_stuff (pi
.dwProcessId
);
1904 /* win32_continue (DBG_CONTINUE, -1); */
1908 win32_mourn_inferior (void)
1910 (void) win32_continue (DBG_CONTINUE
, -1);
1911 i386_cleanup_dregs();
1912 if (open_process_used
)
1914 CHECK (CloseHandle (current_process_handle
));
1915 open_process_used
= 0;
1917 unpush_target (&win32_ops
);
1918 generic_mourn_inferior ();
1921 /* Send a SIGINT to the process group. This acts just like the user typed a
1922 ^C on the controlling terminal. */
1927 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1928 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1929 registers_changed (); /* refresh register state */
1933 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
1934 int write
, struct mem_attrib
*mem
,
1935 struct target_ops
*target
)
1940 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1941 len
, (DWORD
) (uintptr_t) memaddr
));
1942 if (!WriteProcessMemory (current_process_handle
,
1943 (LPVOID
) (uintptr_t) memaddr
, our
,
1946 FlushInstructionCache (current_process_handle
,
1947 (LPCVOID
) (uintptr_t) memaddr
, len
);
1951 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1952 len
, (DWORD
) (uintptr_t) memaddr
));
1953 if (!ReadProcessMemory (current_process_handle
,
1954 (LPCVOID
) (uintptr_t) memaddr
, our
,
1962 win32_kill_inferior (void)
1964 CHECK (TerminateProcess (current_process_handle
, 0));
1968 if (!win32_continue (DBG_CONTINUE
, -1))
1970 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1972 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1976 target_mourn_inferior (); /* or just win32_mourn_inferior? */
1980 win32_prepare_to_store (struct regcache
*regcache
)
1982 /* Do nothing, since we can store individual regs */
1986 win32_can_run (void)
1994 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1995 PIDGET (inferior_ptid
)));
1998 /* Convert pid to printable format. */
2000 win32_pid_to_str (ptid_t ptid
)
2002 static char buf
[80];
2003 int pid
= PIDGET (ptid
);
2005 if ((DWORD
) pid
== current_event
.dwProcessId
)
2006 sprintf (buf
, "process %d", pid
);
2008 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2013 win32_xfer_shared_libraries (struct target_ops
*ops
,
2014 enum target_object object
, const char *annex
,
2015 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2016 ULONGEST offset
, LONGEST len
)
2018 struct obstack obstack
;
2026 obstack_init (&obstack
);
2027 obstack_grow_str (&obstack
, "<library-list>\n");
2028 for (so
= solib_start
.next
; so
; so
= so
->next
)
2029 win32_xfer_shared_library (so
->so_name
, so
->lm_info
->load_addr
, &obstack
);
2030 obstack_grow_str0 (&obstack
, "</library-list>\n");
2032 buf
= obstack_finish (&obstack
);
2033 len_avail
= strlen (buf
);
2034 if (offset
>= len_avail
)
2037 if (len
> len_avail
- offset
)
2038 len
= len_avail
- offset
;
2039 memcpy (readbuf
, buf
+ offset
, len
);
2041 obstack_free (&obstack
, NULL
);
2046 win32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2047 const char *annex
, gdb_byte
*readbuf
,
2048 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
2052 case TARGET_OBJECT_MEMORY
:
2054 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
2055 len
, 0/*write*/, NULL
, ops
);
2057 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
2058 len
, 1/*write*/, NULL
, ops
);
2061 case TARGET_OBJECT_LIBRARIES
:
2062 return win32_xfer_shared_libraries (ops
, object
, annex
, readbuf
,
2063 writebuf
, offset
, len
);
2066 if (ops
->beneath
!= NULL
)
2067 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2068 readbuf
, writebuf
, offset
, len
);
2074 init_win32_ops (void)
2076 win32_ops
.to_shortname
= "child";
2077 win32_ops
.to_longname
= "Win32 child process";
2078 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2079 win32_ops
.to_open
= win32_open
;
2080 win32_ops
.to_close
= win32_close
;
2081 win32_ops
.to_attach
= win32_attach
;
2082 win32_ops
.to_detach
= win32_detach
;
2083 win32_ops
.to_resume
= win32_resume
;
2084 win32_ops
.to_wait
= win32_wait
;
2085 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2086 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2087 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2088 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2089 win32_ops
.to_xfer_partial
= win32_xfer_partial
;
2090 win32_ops
.to_files_info
= win32_files_info
;
2091 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2092 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2093 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2094 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2095 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2096 win32_ops
.to_terminal_ours
= terminal_ours
;
2097 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2098 win32_ops
.to_terminal_info
= child_terminal_info
;
2099 win32_ops
.to_kill
= win32_kill_inferior
;
2100 win32_ops
.to_create_inferior
= win32_create_inferior
;
2101 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2102 win32_ops
.to_can_run
= win32_can_run
;
2103 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2104 win32_ops
.to_pid_to_str
= win32_pid_to_str
;
2105 win32_ops
.to_stop
= win32_stop
;
2106 win32_ops
.to_stratum
= process_stratum
;
2107 win32_ops
.to_has_all_memory
= 1;
2108 win32_ops
.to_has_memory
= 1;
2109 win32_ops
.to_has_stack
= 1;
2110 win32_ops
.to_has_registers
= 1;
2111 win32_ops
.to_has_execution
= 1;
2112 win32_ops
.to_magic
= OPS_MAGIC
;
2113 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2117 set_win32_aliases (char *argv0
)
2119 add_info_alias ("dll", "sharedlibrary", 1);
2123 _initialize_win32_nat (void)
2125 struct cmd_list_element
*c
;
2129 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2130 _("Load dll library symbols from FILE."));
2131 set_cmd_completer (c
, filename_completer
);
2133 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2136 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2137 Set use of shell to start subprocess."), _("\
2138 Show use of shell to start subprocess."), NULL
,
2140 NULL
, /* FIXME: i18n: */
2141 &setlist
, &showlist
);
2143 add_setshow_boolean_cmd ("cygwin-exceptions", class_support
, &cygwin_exceptions
, _("\
2144 Break when an exception is detected in the Cygwin DLL itself."), _("\
2145 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL
,
2147 NULL
, /* FIXME: i18n: */
2148 &setlist
, &showlist
);
2151 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2152 Set creation of new console when creating child process."), _("\
2153 Show creation of new console when creating child process."), NULL
,
2155 NULL
, /* FIXME: i18n: */
2156 &setlist
, &showlist
);
2158 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2159 Set creation of new group when creating child process."), _("\
2160 Show creation of new group when creating child process."), NULL
,
2162 NULL
, /* FIXME: i18n: */
2163 &setlist
, &showlist
);
2165 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2166 Set whether to display execution in child process."), _("\
2167 Show whether to display execution in child process."), NULL
,
2169 NULL
, /* FIXME: i18n: */
2170 &setlist
, &showlist
);
2172 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2173 Set whether to display kernel events in child process."), _("\
2174 Show whether to display kernel events in child process."), NULL
,
2176 NULL
, /* FIXME: i18n: */
2177 &setlist
, &showlist
);
2179 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2180 Set whether to display memory accesses in child process."), _("\
2181 Show whether to display memory accesses in child process."), NULL
,
2183 NULL
, /* FIXME: i18n: */
2184 &setlist
, &showlist
);
2186 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2187 &debug_exceptions
, _("\
2188 Set whether to display kernel exceptions in child process."), _("\
2189 Show whether to display kernel exceptions in child process."), NULL
,
2191 NULL
, /* FIXME: i18n: */
2192 &setlist
, &showlist
);
2194 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2195 _("Print information specific to Win32 debugging."),
2196 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2198 add_cmd ("selector", class_info
, display_selectors
,
2199 _("Display selectors infos."),
2201 add_target (&win32_ops
);
2202 deprecated_init_ui_hook
= set_win32_aliases
;
2205 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2207 /* Pass the address ADDR to the inferior in the I'th debug register.
2208 Here we just store the address in dr array, the registers will be
2209 actually set up when win32_continue is called. */
2211 cygwin_set_dr (int i
, CORE_ADDR addr
)
2214 internal_error (__FILE__
, __LINE__
,
2215 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2216 dr
[i
] = (unsigned) addr
;
2217 debug_registers_changed
= 1;
2218 debug_registers_used
= 1;
2221 /* Pass the value VAL to the inferior in the DR7 debug control
2222 register. Here we just store the address in D_REGS, the watchpoint
2223 will be actually set up in win32_wait. */
2225 cygwin_set_dr7 (unsigned val
)
2228 debug_registers_changed
= 1;
2229 debug_registers_used
= 1;
2232 /* Get the value of the DR6 debug status register from the inferior.
2233 Here we just return the value stored in dr[6]
2234 by the last call to thread_rec for current_event.dwThreadId id. */
2236 cygwin_get_dr6 (void)
2241 /* Determine if the thread referenced by "pid" is alive
2242 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2243 it means that the pid has died. Otherwise it is assumed to be alive. */
2245 win32_win32_thread_alive (ptid_t ptid
)
2247 int pid
= PIDGET (ptid
);
2249 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2254 _initialize_check_for_gdb_ini (void)
2257 if (inhibit_gdbinit
)
2260 homedir
= getenv ("HOME");
2264 char *oldini
= (char *) alloca (strlen (homedir
) +
2265 sizeof ("/gdb.ini"));
2266 strcpy (oldini
, homedir
);
2267 p
= strchr (oldini
, '\0');
2268 if (p
> oldini
&& p
[-1] != '/')
2270 strcpy (p
, "gdb.ini");
2271 if (access (oldini
, 0) == 0)
2273 int len
= strlen (oldini
);
2274 char *newini
= alloca (len
+ 1);
2275 sprintf (newini
, "%.*s.gdbinit",
2276 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2277 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);