1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Solutions, A Red Hat Company.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
26 /* Originally by Steve Chamberlain, sac@cygnus.com */
28 /* We assume we're being built with and will be used for cygwin. */
31 #include "frame.h" /* required by inferior.h */
34 #include "exceptions.h"
37 #include "completer.h"
41 #include <sys/types.h>
46 #include <sys/cygwin.h>
52 #include "gdb_string.h"
53 #include "gdbthread.h"
55 #include <sys/param.h>
61 #include "i386-tdep.h"
62 #include "i387-tdep.h"
64 static struct target_ops win32_ops
;
65 static struct target_so_ops win32_so_ops
;
67 /* The starting and ending address of the cygwin1.dll text segment. */
68 static bfd_vma cygwin_load_start
;
69 static bfd_vma cygwin_load_end
;
71 static int have_saved_context
; /* True if we've saved context from a cygwin signal. */
72 static CONTEXT saved_context
; /* Containes the saved context from a cygwin signal. */
74 /* If we're not using the old Cygwin header file set, define the
75 following which never should have been in the generic Win32 API
76 headers in the first place since they were our own invention... */
77 #ifndef _GNU_H_WINDOWS_H
80 FLAG_TRACE_BIT
= 0x100,
81 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
84 #include <sys/procfs.h>
87 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
88 | CONTEXT_EXTENDED_REGISTERS
90 static unsigned dr
[8];
91 static int debug_registers_changed
;
92 static int debug_registers_used
;
94 /* The string sent by cygwin when it processes a signal.
95 FIXME: This should be in a cygwin include file. */
96 #ifndef _CYGWIN_SIGNAL_STRING
97 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
100 #define CHECK(x) check (x, __FILE__,__LINE__)
101 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
102 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
103 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
104 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
106 static void win32_stop (void);
107 static int win32_win32_thread_alive (ptid_t
);
108 static void win32_kill_inferior (void);
110 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
111 /* Set if a signal was received from the debugged process */
113 /* Thread information structure used to track information that is
114 not available in gdb's thread structure. */
115 typedef struct thread_info_struct
117 struct thread_info_struct
*next
;
128 static thread_info thread_head
;
130 /* The process and thread handles for the above context. */
132 static DEBUG_EVENT current_event
; /* The current debug event from
134 static HANDLE current_process_handle
; /* Currently executing process */
135 static thread_info
*current_thread
; /* Info on currently selected thread */
136 static DWORD main_thread_id
; /* Thread ID of the main thread */
138 /* Counts of things. */
139 static int exception_count
= 0;
140 static int event_count
= 0;
141 static int saw_create
;
144 static int new_console
= 0;
145 static int new_group
= 1;
146 static int debug_exec
= 0; /* show execution */
147 static int debug_events
= 0; /* show events from kernel */
148 static int debug_memory
= 0; /* show target memory accesses */
149 static int debug_exceptions
= 0; /* show target exceptions */
150 static int useshell
= 0; /* use shell for subprocesses */
152 /* This vector maps GDB's idea of a register's number into an address
153 in the win32 exception context vector.
155 It also contains the bit mask needed to load the register in question.
157 One day we could read a reg, we could inspect the context we
158 already have loaded, if it doesn't have the bit set that we need,
159 we read that set of registers in using GetThreadContext. If the
160 context already contains what we need, we just unpack it. Then to
161 write a register, first we have to ensure that the context contains
162 the other regs of the group, and then we copy the info in and set
165 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
166 static const int mappings
[] =
168 context_offset (Eax
),
169 context_offset (Ecx
),
170 context_offset (Edx
),
171 context_offset (Ebx
),
172 context_offset (Esp
),
173 context_offset (Ebp
),
174 context_offset (Esi
),
175 context_offset (Edi
),
176 context_offset (Eip
),
177 context_offset (EFlags
),
178 context_offset (SegCs
),
179 context_offset (SegSs
),
180 context_offset (SegDs
),
181 context_offset (SegEs
),
182 context_offset (SegFs
),
183 context_offset (SegGs
),
184 context_offset (FloatSave
.RegisterArea
[0 * 10]),
185 context_offset (FloatSave
.RegisterArea
[1 * 10]),
186 context_offset (FloatSave
.RegisterArea
[2 * 10]),
187 context_offset (FloatSave
.RegisterArea
[3 * 10]),
188 context_offset (FloatSave
.RegisterArea
[4 * 10]),
189 context_offset (FloatSave
.RegisterArea
[5 * 10]),
190 context_offset (FloatSave
.RegisterArea
[6 * 10]),
191 context_offset (FloatSave
.RegisterArea
[7 * 10]),
192 context_offset (FloatSave
.ControlWord
),
193 context_offset (FloatSave
.StatusWord
),
194 context_offset (FloatSave
.TagWord
),
195 context_offset (FloatSave
.ErrorSelector
),
196 context_offset (FloatSave
.ErrorOffset
),
197 context_offset (FloatSave
.DataSelector
),
198 context_offset (FloatSave
.DataOffset
),
199 context_offset (FloatSave
.ErrorSelector
)
201 context_offset (ExtendedRegisters
[10*16]),
202 context_offset (ExtendedRegisters
[11*16]),
203 context_offset (ExtendedRegisters
[12*16]),
204 context_offset (ExtendedRegisters
[13*16]),
205 context_offset (ExtendedRegisters
[14*16]),
206 context_offset (ExtendedRegisters
[15*16]),
207 context_offset (ExtendedRegisters
[16*16]),
208 context_offset (ExtendedRegisters
[17*16]),
210 context_offset (ExtendedRegisters
[24])
213 #undef context_offset
215 /* This vector maps the target's idea of an exception (extracted
216 from the DEBUG_EVENT structure) to GDB's idea. */
218 struct xlate_exception
221 enum target_signal us
;
224 static const struct xlate_exception
227 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
228 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
229 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
230 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
231 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
232 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
236 check (BOOL ok
, const char *file
, int line
)
239 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
243 /* Find a thread record given a thread id.
244 If get_context then also retrieve the context for this
247 thread_rec (DWORD id
, int get_context
)
251 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
254 if (!th
->suspend_count
&& get_context
)
256 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
257 th
->suspend_count
= SuspendThread (th
->h
) + 1;
258 else if (get_context
< 0)
259 th
->suspend_count
= -1;
260 th
->reload_context
= 1;
268 /* Add a thread to the thread list */
270 win32_add_thread (DWORD id
, HANDLE h
)
274 if ((th
= thread_rec (id
, FALSE
)))
277 th
= XZALLOC (thread_info
);
280 th
->next
= thread_head
.next
;
281 thread_head
.next
= th
;
282 add_thread (pid_to_ptid (id
));
283 /* Set the debug registers for the new thread in they are used. */
284 if (debug_registers_used
)
286 /* Only change the value of the debug registers. */
287 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
288 CHECK (GetThreadContext (th
->h
, &th
->context
));
289 th
->context
.Dr0
= dr
[0];
290 th
->context
.Dr1
= dr
[1];
291 th
->context
.Dr2
= dr
[2];
292 th
->context
.Dr3
= dr
[3];
293 /* th->context.Dr6 = dr[6];
294 FIXME: should we set dr6 also ?? */
295 th
->context
.Dr7
= dr
[7];
296 CHECK (SetThreadContext (th
->h
, &th
->context
));
297 th
->context
.ContextFlags
= 0;
302 /* Clear out any old thread list and reintialize it to a
305 win32_init_thread_list (void)
307 thread_info
*th
= &thread_head
;
309 DEBUG_EVENTS (("gdb: win32_init_thread_list\n"));
311 while (th
->next
!= NULL
)
313 thread_info
*here
= th
->next
;
314 th
->next
= here
->next
;
315 (void) CloseHandle (here
->h
);
318 thread_head
.next
= NULL
;
321 /* Delete a thread from the list of threads */
323 win32_delete_thread (DWORD id
)
328 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
329 delete_thread (pid_to_ptid (id
));
331 for (th
= &thread_head
;
332 th
->next
!= NULL
&& th
->next
->id
!= id
;
336 if (th
->next
!= NULL
)
338 thread_info
*here
= th
->next
;
339 th
->next
= here
->next
;
340 CloseHandle (here
->h
);
346 do_win32_fetch_inferior_registers (int r
)
348 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
352 return; /* Windows sometimes uses a non-existent thread id in its
355 if (current_thread
->reload_context
)
357 if (have_saved_context
)
359 /* Lie about where the program actually is stopped since cygwin has informed us that
360 we should consider the signal to have occurred at another location which is stored
361 in "saved_context. */
362 memcpy (¤t_thread
->context
, &saved_context
, __COPY_CONTEXT_SIZE
);
363 have_saved_context
= 0;
367 thread_info
*th
= current_thread
;
368 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
369 GetThreadContext (th
->h
, &th
->context
);
370 /* Copy dr values from that thread. */
371 dr
[0] = th
->context
.Dr0
;
372 dr
[1] = th
->context
.Dr1
;
373 dr
[2] = th
->context
.Dr2
;
374 dr
[3] = th
->context
.Dr3
;
375 dr
[6] = th
->context
.Dr6
;
376 dr
[7] = th
->context
.Dr7
;
378 current_thread
->reload_context
= 0;
381 #define I387_ST0_REGNUM I386_ST0_REGNUM
383 if (r
== I387_FISEG_REGNUM
)
385 l
= *((long *) context_offset
) & 0xffff;
386 regcache_raw_supply (current_regcache
, r
, (char *) &l
);
388 else if (r
== I387_FOP_REGNUM
)
390 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
391 regcache_raw_supply (current_regcache
, r
, (char *) &l
);
394 regcache_raw_supply (current_regcache
, r
, context_offset
);
397 for (r
= 0; r
< NUM_REGS
; r
++)
398 do_win32_fetch_inferior_registers (r
);
401 #undef I387_ST0_REGNUM
405 win32_fetch_inferior_registers (int r
)
407 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
408 /* Check if current_thread exists. Windows sometimes uses a non-existent
409 thread id in its events */
411 do_win32_fetch_inferior_registers (r
);
415 do_win32_store_inferior_registers (int r
)
418 /* Windows sometimes uses a non-existent thread id in its events */;
420 regcache_raw_collect (current_regcache
, r
,
421 ((char *) ¤t_thread
->context
) + mappings
[r
]);
424 for (r
= 0; r
< NUM_REGS
; r
++)
425 do_win32_store_inferior_registers (r
);
429 /* Store a new register value into the current thread context */
431 win32_store_inferior_registers (int r
)
433 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
434 /* Check if current_thread exists. Windows sometimes uses a non-existent
435 thread id in its events */
437 do_win32_store_inferior_registers (r
);
440 static int psapi_loaded
= 0;
441 static HMODULE psapi_module_handle
= NULL
;
442 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
443 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
444 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
447 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
453 HMODULE
*DllHandle
= dh_buf
;
458 psapi_EnumProcessModules
== NULL
||
459 psapi_GetModuleInformation
== NULL
||
460 psapi_GetModuleFileNameExA
== NULL
)
465 psapi_module_handle
= LoadLibrary ("psapi.dll");
466 if (!psapi_module_handle
)
468 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
471 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
472 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
473 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
474 "GetModuleFileNameExA");
475 if (psapi_EnumProcessModules
== NULL
||
476 psapi_GetModuleInformation
== NULL
||
477 psapi_GetModuleFileNameExA
== NULL
)
482 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
487 if (!ok
|| !cbNeeded
)
490 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
494 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
501 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
503 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
507 error (_("Can't get module info"));
509 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
514 error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
516 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
521 dll_name_ret
[0] = '\0';
525 /* Encapsulate the information required in a call to
526 symbol_file_add_args */
527 struct safe_symbol_file_add_args
531 struct section_addr_info
*addrs
;
534 struct ui_file
*err
, *out
;
538 /* Maintain a linked list of "so" information. */
544 static struct so_list solib_start
, *solib_end
;
546 /* Call symbol_file_add with stderr redirected. We don't care if there
549 safe_symbol_file_add_stub (void *argv
)
551 #define p ((struct safe_symbol_file_add_args *) argv)
552 struct so_list
*so
= &solib_start
;
554 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
559 /* Restore gdb's stderr after calling symbol_file_add */
561 safe_symbol_file_add_cleanup (void *p
)
563 #define sp ((struct safe_symbol_file_add_args *)p)
564 gdb_flush (gdb_stderr
);
565 gdb_flush (gdb_stdout
);
566 ui_file_delete (gdb_stderr
);
567 ui_file_delete (gdb_stdout
);
568 gdb_stderr
= sp
->err
;
569 gdb_stdout
= sp
->out
;
573 /* symbol_file_add wrapper that prevents errors from being displayed. */
574 static struct objfile
*
575 safe_symbol_file_add (char *name
, int from_tty
,
576 struct section_addr_info
*addrs
,
577 int mainline
, int flags
)
579 struct safe_symbol_file_add_args p
;
580 struct cleanup
*cleanup
;
582 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
586 gdb_flush (gdb_stderr
);
587 gdb_flush (gdb_stdout
);
588 gdb_stderr
= ui_file_new ();
589 gdb_stdout
= ui_file_new ();
591 p
.from_tty
= from_tty
;
593 p
.mainline
= mainline
;
595 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
597 do_cleanups (cleanup
);
601 /* Get the loaded address of all sections, given that .text was loaded
602 at text_load. Assumes that all sections are subject to the same
603 relocation offset. Returns NULL if problems occur or if the
604 sections were not relocated. */
606 static struct section_addr_info
*
607 get_relocated_section_addrs (bfd
*abfd
, CORE_ADDR text_load
)
609 struct section_addr_info
*result
= NULL
;
610 int section_count
= bfd_count_sections (abfd
);
611 asection
*text_section
= bfd_get_section_by_name (abfd
, ".text");
616 /* Couldn't get the .text section. Weird. */
618 else if (text_load
== (text_vma
= bfd_get_section_vma (abfd
, text_section
)))
620 /* DLL wasn't relocated. */
624 /* Figure out all sections' loaded addresses. The offset here is
625 such that taking a bfd_get_section_vma() result and adding
626 offset will give the real load address of the section. */
628 CORE_ADDR offset
= text_load
- text_vma
;
630 struct section_table
*table_start
= NULL
;
631 struct section_table
*table_end
= NULL
;
632 struct section_table
*iter
= NULL
;
634 build_section_table (abfd
, &table_start
, &table_end
);
636 for (iter
= table_start
; iter
< table_end
; ++iter
)
638 /* Relocated addresses. */
639 iter
->addr
+= offset
;
640 iter
->endaddr
+= offset
;
643 result
= build_section_addr_info_from_section_table (table_start
,
652 /* Add DLL symbol information. */
654 solib_symbols_add (struct so_list
*so
, CORE_ADDR load_addr
)
656 struct section_addr_info
*addrs
= NULL
;
657 static struct objfile
*result
= NULL
;
658 char *name
= so
->so_name
;
662 /* The symbols in a dll are offset by 0x1000, which is the
663 the offset from 0 of the first byte in an image - because
664 of the file header and the section alignment. */
666 if (!name
|| !name
[0])
669 abfd
= bfd_openr (name
, "pei-i386");
673 /* pei failed - try pe */
674 abfd
= bfd_openr (name
, "pe-i386");
679 if (bfd_check_format (abfd
, bfd_object
))
680 addrs
= get_relocated_section_addrs (abfd
, load_addr
);
685 result
= safe_symbol_file_add (name
, 0, addrs
, 0, OBJF_SHARED
);
686 free_section_addr_info (addrs
);
690 /* Fallback on handling just the .text section. */
691 struct cleanup
*my_cleanups
;
693 addrs
= alloc_section_addr_info (1);
694 my_cleanups
= make_cleanup (xfree
, addrs
);
695 addrs
->other
[0].name
= ".text";
696 addrs
->other
[0].addr
= load_addr
;
698 result
= safe_symbol_file_add (name
, 0, addrs
, 0, OBJF_SHARED
);
699 do_cleanups (my_cleanups
);
702 p
= strchr (so
->so_name
, '\0') - (sizeof ("/cygwin1.dll") - 1);
703 if (p
>= so
->so_name
&& strcasecmp (p
, "/cygwin1.dll") == 0)
705 asection
*text
= bfd_get_section_by_name (abfd
, ".text");
706 cygwin_load_start
= bfd_section_vma (abfd
, text
);
707 cygwin_load_end
= cygwin_load_start
+ bfd_section_size (abfd
, text
);
712 so
->symbols_loaded
= !!result
;
717 register_loaded_dll (const char *name
, DWORD load_addr
, int readsyms
)
720 char buf
[MAX_PATH
+ 1];
721 char cwd
[MAX_PATH
+ 1];
723 WIN32_FIND_DATA w32_fd
;
724 HANDLE h
= FindFirstFile(name
, &w32_fd
);
725 MEMORY_BASIC_INFORMATION m
;
728 if (h
== INVALID_HANDLE_VALUE
)
734 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
736 p
= strrchr (buf
, '\\');
739 SetCurrentDirectory (buf
);
740 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
741 SetCurrentDirectory (cwd
);
745 if (strcasecmp (buf
, "ntdll.dll") == 0)
747 GetSystemDirectory (buf
, sizeof (buf
));
748 strcat (buf
, "\\ntdll.dll");
750 so
= XZALLOC (struct so_list
);
751 so
->lm_info
= (struct lm_info
*) xmalloc (sizeof (struct lm_info
));
752 so
->lm_info
->load_addr
= load_addr
;
753 cygwin_conv_to_posix_path (buf
, so
->so_name
);
754 strcpy (so
->so_original_name
, so
->so_name
);
756 solib_end
->next
= so
;
758 len
= strlen (so
->so_name
);
760 solib_symbols_add (so
, (CORE_ADDR
) load_addr
);
766 get_image_name (HANDLE h
, void *address
, int unicode
)
768 static char buf
[(2 * MAX_PATH
) + 1];
769 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
775 /* Attempt to read the name of the dll that was detected.
776 This is documented to work only when actively debugging
777 a program. It will not work for attached processes. */
781 /* See if we could read the address of a string, and that the
782 address isn't null. */
783 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
784 || done
!= sizeof (address_ptr
) || !address_ptr
)
787 /* Find the length of the string */
788 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
789 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
793 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
796 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
797 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
800 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
806 /* Wait for child to do something. Return pid of child, or -1 in case
807 of error; store status through argument pointer OURSTATUS. */
809 handle_load_dll (void *dummy
)
811 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
812 char dll_buf
[MAX_PATH
+ 1];
813 char *dll_name
= NULL
;
815 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
817 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
818 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
822 if (*dll_name
== '\0')
823 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
827 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000, auto_solib_add
);
833 win32_free_so (struct so_list
*so
)
840 win32_relocate_section_addresses (struct so_list
*so
,
841 struct section_table
*sec
)
848 win32_solib_create_inferior_hook (void)
850 solib_add (NULL
, 0, NULL
, auto_solib_add
);
855 handle_unload_dll (void *dummy
)
857 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
860 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
861 if (so
->next
->lm_info
->load_addr
== lpBaseOfDll
)
863 struct so_list
*sodel
= so
->next
;
864 so
->next
= sodel
->next
;
868 solib_add (NULL
, 0, NULL
, auto_solib_add
);
872 error (_("Error: dll starting at 0x%lx not found."), (DWORD
) lpBaseOfDll
);
877 /* Clear list of loaded DLLs. */
879 win32_clear_solib (void)
881 solib_start
.next
= NULL
;
882 solib_end
= &solib_start
;
886 win32_special_symbol_handling (void)
891 /* Load DLL symbol info. */
893 dll_symbol_command (char *args
, int from_tty
)
899 error (_("dll-symbols requires a file name"));
902 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
904 char *newargs
= (char *) alloca (n
+ 4 + 1);
905 strcpy (newargs
, args
);
906 strcat (newargs
, ".dll");
910 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
913 /* Handle DEBUG_STRING output from child process.
914 Cygwin prepends its messages with a "cygwin:". Interpret this as
915 a Cygwin signal. Otherwise just print the string as a warning. */
917 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
922 if (!target_read_string
923 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
926 else if (strncmp (s
, _CYGWIN_SIGNAL_STRING
, sizeof (_CYGWIN_SIGNAL_STRING
) - 1) != 0)
928 if (strncmp (s
, "cYg", 3) != 0)
933 /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
934 itself and then optionally followed by the thread id and address to saved context
935 within the DLL. If these are supplied, then the given thread is assumed to have
936 issued the signal and the context from the thread is assumed to be stored at the
937 given address in the inferior. Tell gdb to treat this like a real signal. */
939 int sig
= strtol (s
+ sizeof (_CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
940 int gotasig
= target_signal_from_host (sig
);
941 ourstatus
->value
.sig
= gotasig
;
946 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
947 retval
= strtoul (p
, &p
, 0);
949 retval
= main_thread_id
;
950 else if ((x
= (LPCVOID
) strtoul (p
, &p
, 0))
951 && ReadProcessMemory (current_process_handle
, x
,
952 &saved_context
, __COPY_CONTEXT_SIZE
, &n
)
953 && n
== __COPY_CONTEXT_SIZE
)
954 have_saved_context
= 1;
955 current_event
.dwThreadId
= retval
;
965 display_selector (HANDLE thread
, DWORD sel
)
968 if (GetThreadSelectorEntry (thread
, sel
, &info
))
971 printf_filtered ("0x%03lx: ", sel
);
972 if (!info
.HighWord
.Bits
.Pres
)
974 puts_filtered ("Segment not present\n");
977 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
978 (info
.HighWord
.Bits
.BaseMid
<< 16)
980 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
981 if (info
.HighWord
.Bits
.Granularity
)
982 limit
= (limit
<< 12) | 0xfff;
983 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
984 if (info
.HighWord
.Bits
.Default_Big
)
985 puts_filtered(" 32-bit ");
987 puts_filtered(" 16-bit ");
988 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
991 puts_filtered ("Data (Read-Only, Exp-up");
994 puts_filtered ("Data (Read/Write, Exp-up");
997 puts_filtered ("Unused segment (");
1000 puts_filtered ("Data (Read/Write, Exp-down");
1003 puts_filtered ("Code (Exec-Only, N.Conf");
1006 puts_filtered ("Code (Exec/Read, N.Conf");
1009 puts_filtered ("Code (Exec-Only, Conf");
1012 puts_filtered ("Code (Exec/Read, Conf");
1015 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
1017 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
1018 puts_filtered(", N.Acc");
1019 puts_filtered (")\n");
1020 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
1021 puts_filtered("System selector ");
1022 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
1023 if (info
.HighWord
.Bits
.Granularity
)
1024 puts_filtered ("Page granular.\n");
1026 puts_filtered ("Byte granular.\n");
1031 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
1037 display_selectors (char * args
, int from_tty
)
1039 if (!current_thread
)
1041 puts_filtered ("Impossible to display selectors now.\n");
1047 puts_filtered ("Selector $cs\n");
1048 display_selector (current_thread
->h
,
1049 current_thread
->context
.SegCs
);
1050 puts_filtered ("Selector $ds\n");
1051 display_selector (current_thread
->h
,
1052 current_thread
->context
.SegDs
);
1053 puts_filtered ("Selector $es\n");
1054 display_selector (current_thread
->h
,
1055 current_thread
->context
.SegEs
);
1056 puts_filtered ("Selector $ss\n");
1057 display_selector (current_thread
->h
,
1058 current_thread
->context
.SegSs
);
1059 puts_filtered ("Selector $fs\n");
1060 display_selector (current_thread
->h
,
1061 current_thread
->context
.SegFs
);
1062 puts_filtered ("Selector $gs\n");
1063 display_selector (current_thread
->h
,
1064 current_thread
->context
.SegGs
);
1069 sel
= parse_and_eval_long (args
);
1070 printf_filtered ("Selector \"%s\"\n",args
);
1071 display_selector (current_thread
->h
, sel
);
1075 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
1078 info_w32_command (char *args
, int from_tty
)
1080 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1084 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1085 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1086 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1089 handle_exception (struct target_waitstatus
*ourstatus
)
1092 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1094 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1096 /* Record the context of the current thread */
1097 th
= thread_rec (current_event
.dwThreadId
, -1);
1101 case EXCEPTION_ACCESS_VIOLATION
:
1102 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1103 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1105 /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
1106 a kind of exception handling to deal with passed-in invalid addresses. gdb
1107 should not treat these as real SEGVs since they will be silently handled by
1108 cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
1109 and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
1110 within the text segment of the DLL itself. */
1112 bfd_vma addr
= (bfd_vma
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
;
1113 if ((addr
>= cygwin_load_start
&& addr
< cygwin_load_end
)
1114 || (find_pc_partial_function (addr
, &fn
, NULL
, NULL
)
1115 && strncmp (fn
, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1119 case STATUS_STACK_OVERFLOW
:
1120 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1121 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1123 case STATUS_FLOAT_DENORMAL_OPERAND
:
1124 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1125 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1127 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1128 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1129 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1131 case STATUS_FLOAT_INEXACT_RESULT
:
1132 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1133 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1135 case STATUS_FLOAT_INVALID_OPERATION
:
1136 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1137 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1139 case STATUS_FLOAT_OVERFLOW
:
1140 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1141 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1143 case STATUS_FLOAT_STACK_CHECK
:
1144 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1145 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1147 case STATUS_FLOAT_UNDERFLOW
:
1148 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1149 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1151 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1152 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1153 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1155 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1156 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1157 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1159 case STATUS_INTEGER_OVERFLOW
:
1160 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1161 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1163 case EXCEPTION_BREAKPOINT
:
1164 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1165 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1168 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1169 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1171 case DBG_CONTROL_BREAK
:
1172 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1173 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1175 case EXCEPTION_SINGLE_STEP
:
1176 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1177 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1179 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1180 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1181 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1183 case EXCEPTION_PRIV_INSTRUCTION
:
1184 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1185 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1187 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1188 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1189 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1192 /* Treat unhandled first chance exceptions specially. */
1193 if (current_event
.u
.Exception
.dwFirstChance
)
1195 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1196 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1197 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1198 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1202 last_sig
= ourstatus
->value
.sig
;
1206 /* Resume all artificially suspended threads if we are continuing
1209 win32_continue (DWORD continue_status
, int id
)
1215 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1216 current_event
.dwProcessId
, current_event
.dwThreadId
,
1217 continue_status
== DBG_CONTINUE
?
1218 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1219 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1220 current_event
.dwThreadId
,
1223 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1224 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1227 for (i
= 0; i
< th
->suspend_count
; i
++)
1228 (void) ResumeThread (th
->h
);
1229 th
->suspend_count
= 0;
1230 if (debug_registers_changed
)
1232 /* Only change the value of the debug registers */
1233 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1234 th
->context
.Dr0
= dr
[0];
1235 th
->context
.Dr1
= dr
[1];
1236 th
->context
.Dr2
= dr
[2];
1237 th
->context
.Dr3
= dr
[3];
1238 /* th->context.Dr6 = dr[6];
1239 FIXME: should we set dr6 also ?? */
1240 th
->context
.Dr7
= dr
[7];
1241 CHECK (SetThreadContext (th
->h
, &th
->context
));
1242 th
->context
.ContextFlags
= 0;
1246 debug_registers_changed
= 0;
1250 /* Called in pathological case where Windows fails to send a
1251 CREATE_PROCESS_DEBUG_EVENT after an attach. */
1253 fake_create_process (void)
1255 current_process_handle
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
,
1256 current_event
.dwProcessId
);
1257 main_thread_id
= current_event
.dwThreadId
;
1258 current_thread
= win32_add_thread (main_thread_id
,
1259 current_event
.u
.CreateThread
.hThread
);
1260 return main_thread_id
;
1264 win32_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1267 DWORD continue_status
= DBG_CONTINUE
;
1269 int pid
= PIDGET (ptid
);
1271 if (sig
!= TARGET_SIGNAL_0
)
1273 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1275 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1277 else if (sig
== last_sig
)
1278 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1281 /* This code does not seem to work, because
1282 the kernel does probably not consider changes in the ExceptionRecord
1283 structure when passing the exception to the inferior.
1284 Note that this seems possible in the exception handler itself. */
1287 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1288 if (xlate
[i
].us
== sig
)
1290 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1292 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1295 if (continue_status
== DBG_CONTINUE
)
1297 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1301 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1305 last_sig
= TARGET_SIGNAL_0
;
1307 DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
1310 /* Get context for currently selected thread */
1311 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1316 /* Single step by setting t bit */
1317 win32_fetch_inferior_registers (PS_REGNUM
);
1318 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1321 if (th
->context
.ContextFlags
)
1323 if (debug_registers_changed
)
1325 th
->context
.Dr0
= dr
[0];
1326 th
->context
.Dr1
= dr
[1];
1327 th
->context
.Dr2
= dr
[2];
1328 th
->context
.Dr3
= dr
[3];
1329 /* th->context.Dr6 = dr[6];
1330 FIXME: should we set dr6 also ?? */
1331 th
->context
.Dr7
= dr
[7];
1333 CHECK (SetThreadContext (th
->h
, &th
->context
));
1334 th
->context
.ContextFlags
= 0;
1338 /* Allow continuing with the same signal that interrupted us.
1339 Otherwise complain. */
1341 win32_continue (continue_status
, pid
);
1344 /* Get the next event from the child. Return 1 if the event requires
1345 handling by WFI (or whatever).
1348 get_win32_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1351 DWORD continue_status
, event_code
;
1353 static thread_info dummy_thread_info
;
1357 last_sig
= TARGET_SIGNAL_0
;
1359 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1363 continue_status
= DBG_CONTINUE
;
1365 event_code
= current_event
.dwDebugEventCode
;
1366 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1368 have_saved_context
= 0;
1372 case CREATE_THREAD_DEBUG_EVENT
:
1373 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1374 (unsigned) current_event
.dwProcessId
,
1375 (unsigned) current_event
.dwThreadId
,
1376 "CREATE_THREAD_DEBUG_EVENT"));
1377 if (saw_create
!= 1)
1379 if (!saw_create
&& attach_flag
)
1381 /* Kludge around a Windows bug where first event is a create
1382 thread event. Caused when attached process does not have
1384 retval
= ourstatus
->value
.related_pid
= fake_create_process ();
1389 /* Record the existence of this thread */
1390 th
= win32_add_thread (current_event
.dwThreadId
,
1391 current_event
.u
.CreateThread
.hThread
);
1393 printf_unfiltered ("[New %s]\n",
1395 pid_to_ptid (current_event
.dwThreadId
)));
1396 retval
= current_event
.dwThreadId
;
1399 case EXIT_THREAD_DEBUG_EVENT
:
1400 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1401 (unsigned) current_event
.dwProcessId
,
1402 (unsigned) current_event
.dwThreadId
,
1403 "EXIT_THREAD_DEBUG_EVENT"));
1404 if (current_event
.dwThreadId
!= main_thread_id
)
1406 win32_delete_thread (current_event
.dwThreadId
);
1407 th
= &dummy_thread_info
;
1411 case CREATE_PROCESS_DEBUG_EVENT
:
1412 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1413 (unsigned) current_event
.dwProcessId
,
1414 (unsigned) current_event
.dwThreadId
,
1415 "CREATE_PROCESS_DEBUG_EVENT"));
1416 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1417 if (++saw_create
!= 1)
1419 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1423 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1425 win32_delete_thread (main_thread_id
);
1426 main_thread_id
= current_event
.dwThreadId
;
1427 /* Add the main thread */
1428 th
= win32_add_thread (main_thread_id
,
1429 current_event
.u
.CreateProcessInfo
.hThread
);
1430 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1433 case EXIT_PROCESS_DEBUG_EVENT
:
1434 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1435 (unsigned) current_event
.dwProcessId
,
1436 (unsigned) current_event
.dwThreadId
,
1437 "EXIT_PROCESS_DEBUG_EVENT"));
1438 if (saw_create
!= 1)
1440 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1441 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1442 CloseHandle (current_process_handle
);
1443 retval
= main_thread_id
;
1446 case LOAD_DLL_DEBUG_EVENT
:
1447 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1448 (unsigned) current_event
.dwProcessId
,
1449 (unsigned) current_event
.dwThreadId
,
1450 "LOAD_DLL_DEBUG_EVENT"));
1451 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1452 if (saw_create
!= 1)
1454 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1455 registers_changed (); /* mark all regs invalid */
1456 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1457 ourstatus
->value
.integer
= 0;
1458 retval
= main_thread_id
;
1459 re_enable_breakpoints_in_shlibs ();
1462 case UNLOAD_DLL_DEBUG_EVENT
:
1463 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1464 (unsigned) current_event
.dwProcessId
,
1465 (unsigned) current_event
.dwThreadId
,
1466 "UNLOAD_DLL_DEBUG_EVENT"));
1467 if (saw_create
!= 1)
1469 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1470 registers_changed (); /* mark all regs invalid */
1471 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1472 does not exist yet. */
1475 case EXCEPTION_DEBUG_EVENT
:
1476 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1477 (unsigned) current_event
.dwProcessId
,
1478 (unsigned) current_event
.dwThreadId
,
1479 "EXCEPTION_DEBUG_EVENT"));
1480 if (saw_create
!= 1)
1482 switch (handle_exception (ourstatus
))
1485 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1488 retval
= current_event
.dwThreadId
;
1492 continue_status
= -1;
1497 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1498 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1499 (unsigned) current_event
.dwProcessId
,
1500 (unsigned) current_event
.dwThreadId
,
1501 "OUTPUT_DEBUG_STRING_EVENT"));
1502 if (saw_create
!= 1)
1504 retval
= handle_output_debug_string (ourstatus
);
1508 if (saw_create
!= 1)
1510 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1511 (DWORD
) current_event
.dwProcessId
,
1512 (DWORD
) current_event
.dwThreadId
);
1513 printf_unfiltered (" unknown event code %ld\n",
1514 current_event
.dwDebugEventCode
);
1518 if (!retval
|| saw_create
!= 1)
1520 if (continue_status
== -1)
1521 win32_resume (ptid
, 0, 1);
1523 CHECK (win32_continue (continue_status
, -1));
1527 inferior_ptid
= pid_to_ptid (retval
);
1528 current_thread
= th
?: thread_rec (current_event
.dwThreadId
, TRUE
);
1535 /* Wait for interesting events to occur in the target process. */
1537 win32_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1539 int pid
= PIDGET (ptid
);
1541 /* We loop when we get a non-standard exception rather than return
1542 with a SPURIOUS because resume can try and step or modify things,
1543 which needs a current_thread->h. But some of these exceptions mark
1544 the birth or death of threads, which mean that the current thread
1545 isn't necessarily what you think it is. */
1549 int retval
= get_win32_debug_event (pid
, ourstatus
);
1551 return pid_to_ptid (retval
);
1556 if (deprecated_ui_loop_hook
!= NULL
)
1557 detach
= deprecated_ui_loop_hook (0);
1560 win32_kill_inferior ();
1566 do_initial_win32_stuff (DWORD pid
)
1568 extern int stop_after_trap
;
1571 last_sig
= TARGET_SIGNAL_0
;
1573 exception_count
= 0;
1574 debug_registers_changed
= 0;
1575 debug_registers_used
= 0;
1576 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1578 current_event
.dwProcessId
= pid
;
1579 memset (¤t_event
, 0, sizeof (current_event
));
1580 push_target (&win32_ops
);
1581 disable_breakpoints_in_shlibs (1);
1582 win32_clear_solib ();
1583 clear_proceed_status ();
1584 init_wait_for_inferior ();
1586 target_terminal_init ();
1587 target_terminal_inferior ();
1591 stop_after_trap
= 1;
1592 wait_for_inferior ();
1593 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1594 resume (0, stop_signal
);
1598 stop_after_trap
= 0;
1602 /* Since Windows XP, detaching from a process is supported by Windows.
1603 The following code tries loading the appropriate functions dynamically.
1604 If loading these functions succeeds use them to actually detach from
1605 the inferior process, otherwise behave as usual, pretending that
1606 detach has worked. */
1607 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1608 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1611 has_detach_ability (void)
1613 static HMODULE kernel32
= NULL
;
1616 kernel32
= LoadLibrary ("kernel32.dll");
1619 if (!DebugSetProcessKillOnExit
)
1620 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1621 "DebugSetProcessKillOnExit");
1622 if (!DebugActiveProcessStop
)
1623 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1624 "DebugActiveProcessStop");
1625 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1631 /* Try to set or remove a user privilege to the current process. Return -1
1632 if that fails, the previous setting of that privilege otherwise.
1634 This code is copied from the Cygwin source code and rearranged to allow
1635 dynamically loading of the needed symbols from advapi32 which is only
1636 available on NT/2K/XP. */
1638 set_process_privilege (const char *privilege
, BOOL enable
)
1640 static HMODULE advapi32
= NULL
;
1641 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1642 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1643 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1644 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1646 HANDLE token_hdl
= NULL
;
1648 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1652 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1657 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1659 if (!OpenProcessToken
)
1660 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1661 if (!LookupPrivilegeValue
)
1662 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1663 "LookupPrivilegeValueA");
1664 if (!AdjustTokenPrivileges
)
1665 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1666 "AdjustTokenPrivileges");
1667 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1674 if (!OpenProcessToken (GetCurrentProcess (),
1675 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1679 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1682 new_priv
.PrivilegeCount
= 1;
1683 new_priv
.Privileges
[0].Luid
= restore_priv
;
1684 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1686 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1687 sizeof orig_priv
, &orig_priv
, &size
))
1690 /* Disabled, otherwise every `attach' in an unprivileged user session
1691 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1693 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1694 be enabled. GetLastError () returns an correct error code, though. */
1695 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1699 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1703 CloseHandle (token_hdl
);
1708 /* Attach to process PID, then initialize for debugging it. */
1710 win32_attach (char *args
, int from_tty
)
1716 error_no_arg (_("process-id to attach"));
1718 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1720 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1721 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1724 pid
= strtoul (args
, 0, 0); /* Windows pid */
1726 win32_init_thread_list ();
1727 ok
= DebugActiveProcess (pid
);
1732 /* Try fall back to Cygwin pid */
1733 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1736 ok
= DebugActiveProcess (pid
);
1739 error (_("Can't attach to process."));
1742 if (has_detach_ability ())
1743 DebugSetProcessKillOnExit (FALSE
);
1749 char *exec_file
= (char *) get_exec_file (0);
1752 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1753 target_pid_to_str (pid_to_ptid (pid
)));
1755 printf_unfiltered ("Attaching to %s\n",
1756 target_pid_to_str (pid_to_ptid (pid
)));
1758 gdb_flush (gdb_stdout
);
1761 do_initial_win32_stuff (pid
);
1762 target_terminal_ours ();
1766 win32_detach (char *args
, int from_tty
)
1770 if (has_detach_ability ())
1772 delete_command (NULL
, 0);
1773 win32_continue (DBG_CONTINUE
, -1);
1774 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1776 error (_("Can't detach process %lu (error %lu)"),
1777 current_event
.dwProcessId
, GetLastError ());
1780 DebugSetProcessKillOnExit (FALSE
);
1782 if (detached
&& from_tty
)
1784 char *exec_file
= get_exec_file (0);
1787 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1788 current_event
.dwProcessId
);
1789 gdb_flush (gdb_stdout
);
1791 inferior_ptid
= null_ptid
;
1792 unpush_target (&win32_ops
);
1796 win32_pid_to_exec_file (int pid
)
1798 /* Try to find the process path using the Cygwin internal process list
1799 pid isn't a valid pid, unfortunately. Use current_event.dwProcessId
1801 /* TODO: Also find native Windows processes using CW_GETPINFO_FULL. */
1803 static char path
[MAX_PATH
+ 1];
1804 char *path_ptr
= NULL
;
1806 struct external_pinfo
*pinfo
;
1808 cygwin_internal (CW_LOCK_PINFO
, 1000);
1810 (pinfo
= (struct external_pinfo
*)
1811 cygwin_internal (CW_GETPINFO
, cpid
| CW_NEXTPID
));
1814 if (pinfo
->dwProcessId
== current_event
.dwProcessId
) /* Got it */
1816 cygwin_conv_to_full_posix_path (pinfo
->progname
, path
);
1821 cygwin_internal (CW_UNLOCK_PINFO
);
1825 /* Print status information about what we're accessing. */
1828 win32_files_info (struct target_ops
*ignore
)
1830 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1831 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1835 win32_open (char *arg
, int from_tty
)
1837 error (_("Use the \"run\" command to start a Unix child process."));
1840 /* Function called by qsort to sort environment strings. */
1842 env_sort (const void *a
, const void *b
)
1844 const char **p
= (const char **) a
;
1845 const char **q
= (const char **) b
;
1846 return strcasecmp (*p
, *q
);
1849 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1850 EXEC_FILE is the file to run.
1851 ALLARGS is a string containing the arguments to the program.
1852 ENV is the environment vector to pass. Errors reported with error(). */
1855 win32_create_inferior (char *exec_file
, char *allargs
, char **in_env
,
1863 PROCESS_INFORMATION pi
;
1867 char real_path
[MAXPATHLEN
];
1869 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1872 int ostdin
, ostdout
, ostderr
;
1873 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1876 error (_("No executable specified, use `target exec'."));
1878 memset (&si
, 0, sizeof (si
));
1879 si
.cb
= sizeof (si
);
1883 flags
= DEBUG_ONLY_THIS_PROCESS
;
1884 cygwin_conv_to_win32_path (exec_file
, real_path
);
1890 sh
= getenv ("SHELL");
1893 cygwin_conv_to_win32_path (sh
, shell
);
1894 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1895 + strlen (allargs
) + 2);
1896 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1897 allargs
= newallargs
;
1899 flags
= DEBUG_PROCESS
;
1903 flags
|= CREATE_NEW_PROCESS_GROUP
;
1906 flags
|= CREATE_NEW_CONSOLE
;
1910 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1911 strcpy (args
, toexec
);
1913 strcat (args
, allargs
);
1915 /* Prepare the environment vars for CreateProcess. */
1917 /* This code used to assume all env vars were file names and would
1918 translate them all to win32 style. That obviously doesn't work in the
1919 general case. The current rule is that we only translate PATH.
1920 We need to handle PATH because we're about to call CreateProcess and
1921 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1922 in both posix and win32 environments. cygwin.dll will change it back
1923 to posix style if necessary. */
1925 static const char *conv_path_names
[] =
1931 /* CreateProcess takes the environment list as a null terminated set of
1932 strings (i.e. two nulls terminate the list). */
1934 /* Get total size for env strings. */
1935 for (envlen
= 0, i
= 0; in_env
[i
] && *in_env
[i
]; i
++)
1939 for (j
= 0; conv_path_names
[j
]; j
++)
1941 len
= strlen (conv_path_names
[j
]);
1942 if (strncmp (conv_path_names
[j
], in_env
[i
], len
) == 0)
1944 if (cygwin_posix_path_list_p (in_env
[i
] + len
))
1946 + cygwin_posix_to_win32_path_list_buf_size (in_env
[i
] + len
);
1948 envlen
+= strlen (in_env
[i
]) + 1;
1952 if (conv_path_names
[j
] == NULL
)
1953 envlen
+= strlen (in_env
[i
]) + 1;
1956 size_t envsize
= sizeof (in_env
[0]) * (i
+ 1);
1957 char **env
= (char **) alloca (envsize
);
1958 memcpy (env
, in_env
, envsize
);
1959 /* Windows programs expect the environment block to be sorted. */
1960 qsort (env
, i
, sizeof (char *), env_sort
);
1962 winenv
= alloca (envlen
+ 1);
1964 /* Copy env strings into new buffer. */
1965 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1969 for (j
= 0; conv_path_names
[j
]; j
++)
1971 len
= strlen (conv_path_names
[j
]);
1972 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1974 if (cygwin_posix_path_list_p (env
[i
] + len
))
1976 memcpy (temp
, env
[i
], len
);
1977 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1980 strcpy (temp
, env
[i
]);
1984 if (conv_path_names
[j
] == NULL
)
1985 strcpy (temp
, env
[i
]);
1987 temp
+= strlen (temp
) + 1;
1990 /* Final nil string to terminate new env. */
1994 if (!inferior_io_terminal
)
1995 tty
= ostdin
= ostdout
= ostderr
= -1;
1998 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
2001 print_sys_errmsg (inferior_io_terminal
, errno
);
2002 ostdin
= ostdout
= ostderr
= -1;
2015 win32_init_thread_list ();
2016 ret
= CreateProcess (0,
2017 args
, /* command line */
2018 NULL
, /* Security */
2020 TRUE
, /* inherit handles */
2021 flags
, /* start flags */
2023 NULL
, /* current directory */
2038 error (_("Error creating process %s, (error %d)."),
2039 exec_file
, (unsigned) GetLastError ());
2041 CloseHandle (pi
.hThread
);
2042 CloseHandle (pi
.hProcess
);
2044 if (useshell
&& shell
[0] != '\0')
2049 do_initial_win32_stuff (pi
.dwProcessId
);
2051 /* win32_continue (DBG_CONTINUE, -1); */
2055 win32_mourn_inferior (void)
2057 (void) win32_continue (DBG_CONTINUE
, -1);
2058 i386_cleanup_dregs();
2059 unpush_target (&win32_ops
);
2060 generic_mourn_inferior ();
2063 /* Send a SIGINT to the process group. This acts just like the user typed a
2064 ^C on the controlling terminal. */
2069 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
2070 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
2071 registers_changed (); /* refresh register state */
2075 win32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*our
, int len
,
2076 int write
, struct mem_attrib
*mem
,
2077 struct target_ops
*target
)
2082 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
2083 len
, (DWORD
) memaddr
));
2084 if (!WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
2087 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
2091 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2092 len
, (DWORD
) memaddr
));
2093 if (!ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
,
2101 win32_kill_inferior (void)
2103 CHECK (TerminateProcess (current_process_handle
, 0));
2107 if (!win32_continue (DBG_CONTINUE
, -1))
2109 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
2111 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
2115 CHECK (CloseHandle (current_process_handle
));
2117 /* this may fail in an attached process so don't check. */
2118 if (current_thread
&& current_thread
->h
)
2119 (void) CloseHandle (current_thread
->h
);
2120 target_mourn_inferior (); /* or just win32_mourn_inferior? */
2124 win32_prepare_to_store (void)
2126 /* Do nothing, since we can store individual regs */
2130 win32_can_run (void)
2138 DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2139 PIDGET (inferior_ptid
)));
2142 /* Convert pid to printable format. */
2144 cygwin_pid_to_str (ptid_t ptid
)
2146 static char buf
[80];
2147 int pid
= PIDGET (ptid
);
2149 if ((DWORD
) pid
== current_event
.dwProcessId
)
2150 sprintf (buf
, "process %d", pid
);
2152 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2158 struct target_ops
*target
;
2160 } map_code_section_args
;
2163 map_single_dll_code_section (bfd
*abfd
, asection
*sect
, void *obj
)
2167 struct section_table
*new_target_sect_ptr
;
2169 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2170 struct target_ops
*target
= args
->target
;
2171 if (sect
->flags
& SEC_CODE
)
2173 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2175 if (target
->to_sections
)
2177 old
= target
->to_sections_end
- target
->to_sections
;
2178 target
->to_sections
= (struct section_table
*)
2179 xrealloc ((char *) target
->to_sections
,
2180 (sizeof (struct section_table
)) * (1 + old
));
2185 target
->to_sections
= (struct section_table
*)
2186 xmalloc ((sizeof (struct section_table
)));
2188 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2190 /* Update the to_sections field in the core_ops structure
2194 core_ops
.to_sections
= target
->to_sections
;
2195 core_ops
.to_sections_end
= target
->to_sections_end
;
2197 new_target_sect_ptr
= target
->to_sections
+ old
;
2198 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2199 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2200 bfd_section_size (abfd
, sect
);;
2201 new_target_sect_ptr
->the_bfd_section
= sect
;
2202 new_target_sect_ptr
->bfd
= abfd
;
2207 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2210 map_code_section_args map_args
;
2211 asection
*lowest_sect
;
2213 if (dll_name
== NULL
|| target
== NULL
)
2215 name
= xstrdup (dll_name
);
2216 dll_bfd
= bfd_openr (name
, "pei-i386");
2217 if (dll_bfd
== NULL
)
2220 if (bfd_check_format (dll_bfd
, bfd_object
))
2222 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2223 if (lowest_sect
== NULL
)
2225 map_args
.target
= target
;
2226 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2228 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2235 core_section_load_dll_symbols (bfd
*abfd
, asection
*sect
, void *obj
)
2237 struct target_ops
*target
= (struct target_ops
*) obj
;
2242 struct win32_pstatus
*pstatus
;
2247 struct objfile
*objfile
;
2248 const char *dll_basename
;
2250 if (strncmp (sect
->name
, ".module", 7) != 0)
2253 buf
= (char *) xmalloc (bfd_get_section_size (sect
) + 1);
2256 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2259 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, bfd_get_section_size (sect
)))
2262 pstatus
= (struct win32_pstatus
*) buf
;
2264 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2265 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2266 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> bfd_get_section_size (sect
))
2269 dll_name
= pstatus
->data
.module_info
.module_name
;
2271 if (!(dll_basename
= strrchr (dll_name
, '/')))
2272 dll_basename
= dll_name
;
2276 ALL_OBJFILES (objfile
)
2278 char *objfile_basename
= strrchr (objfile
->name
, '/');
2280 if (objfile_basename
&&
2281 strcasecmp (dll_basename
, objfile_basename
+ 1) == 0)
2285 base_addr
+= 0x1000;
2286 dll_name
= register_loaded_dll (dll_name
, base_addr
, 1);
2288 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
, target
))
2289 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2297 static struct so_list
*
2298 win32_current_sos (void)
2300 struct so_list
*sop
;
2301 struct so_list
*start
= NULL
;
2302 struct so_list
*last
= NULL
;
2304 if (!solib_start
.next
&& core_bfd
)
2306 win32_clear_solib ();
2307 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
,
2311 for (sop
= solib_start
.next
; sop
; sop
= sop
->next
)
2313 struct so_list
*new = XZALLOC (struct so_list
);
2314 strcpy (new->so_name
, sop
->so_name
);
2315 strcpy (new->so_original_name
, sop
->so_original_name
);
2329 fetch_elf_core_registers (char *core_reg_sect
,
2330 unsigned core_reg_size
,
2335 if (core_reg_size
< sizeof (CONTEXT
))
2337 error (_("Core file register section too small (%u bytes)."), core_reg_size
);
2340 for (r
= 0; r
< NUM_REGS
; r
++)
2341 regcache_raw_supply (current_regcache
, r
, core_reg_sect
+ mappings
[r
]);
2345 init_win32_ops (void)
2347 win32_ops
.to_shortname
= "child";
2348 win32_ops
.to_longname
= "Win32 child process";
2349 win32_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2350 win32_ops
.to_open
= win32_open
;
2351 win32_ops
.to_close
= win32_close
;
2352 win32_ops
.to_attach
= win32_attach
;
2353 win32_ops
.to_detach
= win32_detach
;
2354 win32_ops
.to_resume
= win32_resume
;
2355 win32_ops
.to_wait
= win32_wait
;
2356 win32_ops
.to_fetch_registers
= win32_fetch_inferior_registers
;
2357 win32_ops
.to_store_registers
= win32_store_inferior_registers
;
2358 win32_ops
.to_prepare_to_store
= win32_prepare_to_store
;
2359 win32_ops
.deprecated_xfer_memory
= win32_xfer_memory
;
2360 win32_ops
.to_files_info
= win32_files_info
;
2361 win32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2362 win32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2363 win32_ops
.to_terminal_init
= terminal_init_inferior
;
2364 win32_ops
.to_terminal_inferior
= terminal_inferior
;
2365 win32_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2366 win32_ops
.to_terminal_ours
= terminal_ours
;
2367 win32_ops
.to_terminal_save_ours
= terminal_save_ours
;
2368 win32_ops
.to_terminal_info
= child_terminal_info
;
2369 win32_ops
.to_kill
= win32_kill_inferior
;
2370 win32_ops
.to_create_inferior
= win32_create_inferior
;
2371 win32_ops
.to_mourn_inferior
= win32_mourn_inferior
;
2372 win32_ops
.to_can_run
= win32_can_run
;
2373 win32_ops
.to_thread_alive
= win32_win32_thread_alive
;
2374 win32_ops
.to_pid_to_str
= cygwin_pid_to_str
;
2375 win32_ops
.to_stop
= win32_stop
;
2376 win32_ops
.to_stratum
= process_stratum
;
2377 win32_ops
.to_has_all_memory
= 1;
2378 win32_ops
.to_has_memory
= 1;
2379 win32_ops
.to_has_stack
= 1;
2380 win32_ops
.to_has_registers
= 1;
2381 win32_ops
.to_has_execution
= 1;
2382 win32_ops
.to_magic
= OPS_MAGIC
;
2383 win32_ops
.to_pid_to_exec_file
= win32_pid_to_exec_file
;
2385 win32_so_ops
.relocate_section_addresses
= win32_relocate_section_addresses
;
2386 win32_so_ops
.free_so
= win32_free_so
;
2387 win32_so_ops
.clear_solib
= win32_clear_solib
;
2388 win32_so_ops
.solib_create_inferior_hook
= win32_solib_create_inferior_hook
;
2389 win32_so_ops
.special_symbol_handling
= win32_special_symbol_handling
;
2390 win32_so_ops
.current_sos
= win32_current_sos
;
2391 win32_so_ops
.open_symbol_file_object
= NULL
;
2392 win32_so_ops
.in_dynsym_resolve_code
= NULL
;
2394 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
2395 current_target_so_ops
= &win32_so_ops
;
2399 set_win32_aliases (char *argv0
)
2401 add_info_alias ("dll", "sharedlibrary", 1);
2405 _initialize_win32_nat (void)
2407 struct cmd_list_element
*c
;
2411 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2412 _("Load dll library symbols from FILE."));
2413 set_cmd_completer (c
, filename_completer
);
2415 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2417 add_setshow_boolean_cmd ("shell", class_support
, &useshell
, _("\
2418 Set use of shell to start subprocess."), _("\
2419 Show use of shell to start subprocess."), NULL
,
2421 NULL
, /* FIXME: i18n: */
2422 &setlist
, &showlist
);
2424 add_setshow_boolean_cmd ("new-console", class_support
, &new_console
, _("\
2425 Set creation of new console when creating child process."), _("\
2426 Show creation of new console when creating child process."), NULL
,
2428 NULL
, /* FIXME: i18n: */
2429 &setlist
, &showlist
);
2431 add_setshow_boolean_cmd ("new-group", class_support
, &new_group
, _("\
2432 Set creation of new group when creating child process."), _("\
2433 Show creation of new group when creating child process."), NULL
,
2435 NULL
, /* FIXME: i18n: */
2436 &setlist
, &showlist
);
2438 add_setshow_boolean_cmd ("debugexec", class_support
, &debug_exec
, _("\
2439 Set whether to display execution in child process."), _("\
2440 Show whether to display execution in child process."), NULL
,
2442 NULL
, /* FIXME: i18n: */
2443 &setlist
, &showlist
);
2445 add_setshow_boolean_cmd ("debugevents", class_support
, &debug_events
, _("\
2446 Set whether to display kernel events in child process."), _("\
2447 Show whether to display kernel events in child process."), NULL
,
2449 NULL
, /* FIXME: i18n: */
2450 &setlist
, &showlist
);
2452 add_setshow_boolean_cmd ("debugmemory", class_support
, &debug_memory
, _("\
2453 Set whether to display memory accesses in child process."), _("\
2454 Show whether to display memory accesses in child process."), NULL
,
2456 NULL
, /* FIXME: i18n: */
2457 &setlist
, &showlist
);
2459 add_setshow_boolean_cmd ("debugexceptions", class_support
,
2460 &debug_exceptions
, _("\
2461 Set whether to display kernel exceptions in child process."), _("\
2462 Show whether to display kernel exceptions in child process."), NULL
,
2464 NULL
, /* FIXME: i18n: */
2465 &setlist
, &showlist
);
2467 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2468 _("Print information specific to Win32 debugging."),
2469 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2471 add_cmd ("selector", class_info
, display_selectors
,
2472 _("Display selectors infos."),
2474 add_target (&win32_ops
);
2475 deprecated_init_ui_hook
= set_win32_aliases
;
2478 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2480 /* Pass the address ADDR to the inferior in the I'th debug register.
2481 Here we just store the address in dr array, the registers will be
2482 actually set up when win32_continue is called. */
2484 cygwin_set_dr (int i
, CORE_ADDR addr
)
2487 internal_error (__FILE__
, __LINE__
,
2488 _("Invalid register %d in cygwin_set_dr.\n"), i
);
2489 dr
[i
] = (unsigned) addr
;
2490 debug_registers_changed
= 1;
2491 debug_registers_used
= 1;
2494 /* Pass the value VAL to the inferior in the DR7 debug control
2495 register. Here we just store the address in D_REGS, the watchpoint
2496 will be actually set up in win32_wait. */
2498 cygwin_set_dr7 (unsigned val
)
2501 debug_registers_changed
= 1;
2502 debug_registers_used
= 1;
2505 /* Get the value of the DR6 debug status register from the inferior.
2506 Here we just return the value stored in dr[6]
2507 by the last call to thread_rec for current_event.dwThreadId id. */
2509 cygwin_get_dr6 (void)
2514 /* Determine if the thread referenced by "pid" is alive
2515 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2516 it means that the pid has died. Otherwise it is assumed to be alive. */
2518 win32_win32_thread_alive (ptid_t ptid
)
2520 int pid
= PIDGET (ptid
);
2522 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2526 static struct core_fns win32_elf_core_fns
=
2528 bfd_target_elf_flavour
,
2529 default_check_format
,
2530 default_core_sniffer
,
2531 fetch_elf_core_registers
,
2536 _initialize_core_win32 (void)
2538 deprecated_add_core_fns (&win32_elf_core_fns
);
2542 _initialize_check_for_gdb_ini (void)
2545 if (inhibit_gdbinit
)
2548 homedir
= getenv ("HOME");
2552 char *oldini
= (char *) alloca (strlen (homedir
) +
2553 sizeof ("/gdb.ini"));
2554 strcpy (oldini
, homedir
);
2555 p
= strchr (oldini
, '\0');
2556 if (p
> oldini
&& p
[-1] != '/')
2558 strcpy (p
, "gdb.ini");
2559 if (access (oldini
, 0) == 0)
2561 int len
= strlen (oldini
);
2562 char *newini
= alloca (len
+ 1);
2563 sprintf (newini
, "%.*s.gdbinit",
2564 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2565 warning (_("obsolete '%s' found. Rename to '%s'."), oldini
, newini
);