1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free
4 Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Originally by Steve Chamberlain, sac@cygnus.com */
27 /* We assume we're being built with and will be used for cygwin. */
30 #include "tm.h" /* required for SSE registers */
31 #include "frame.h" /* required by inferior.h */
36 #include "completer.h"
39 #include "i386-tdep.h"
41 #include <sys/types.h>
46 #include <sys/cygwin.h>
51 #include "gdb_string.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
57 /* The ui's event loop. */
58 extern int (*ui_loop_hook
) (int signo
);
60 /* If we're not using the old Cygwin header file set, define the
61 following which never should have been in the generic Win32 API
62 headers in the first place since they were our own invention... */
63 #ifndef _GNU_H_WINDOWS_H
66 FLAG_TRACE_BIT
= 0x100,
67 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
70 #include <sys/procfs.h>
74 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
75 | CONTEXT_EXTENDED_REGISTERS
77 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS
80 static unsigned dr
[8];
81 static int debug_registers_changed
= 0;
82 static int debug_registers_used
= 0;
84 /* The string sent by cygwin when it processes a signal.
85 FIXME: This should be in a cygwin include file. */
86 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
88 #define CHECK(x) check (x, __FILE__,__LINE__)
89 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
90 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
91 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
92 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
94 /* Forward declaration */
95 extern struct target_ops child_ops
;
97 static void child_stop (void);
98 static int win32_child_thread_alive (ptid_t
);
99 void child_kill_inferior (void);
101 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
102 /* Set if a signal was received from the debugged process */
104 /* Thread information structure used to track information that is
105 not available in gdb's thread structure. */
106 typedef struct thread_info_struct
108 struct thread_info_struct
*next
;
118 static thread_info thread_head
;
120 /* The process and thread handles for the above context. */
122 static DEBUG_EVENT current_event
; /* The current debug event from
124 static HANDLE current_process_handle
; /* Currently executing process */
125 static thread_info
*current_thread
; /* Info on currently selected thread */
126 static DWORD main_thread_id
; /* Thread ID of the main thread */
128 /* Counts of things. */
129 static int exception_count
= 0;
130 static int event_count
= 0;
131 static int saw_create
;
134 static int new_console
= 0;
135 static int new_group
= 1;
136 static int debug_exec
= 0; /* show execution */
137 static int debug_events
= 0; /* show events from kernel */
138 static int debug_memory
= 0; /* show target memory accesses */
139 static int debug_exceptions
= 0; /* show target exceptions */
140 static int useshell
= 0; /* use shell for subprocesses */
143 static char shell
[MAX_PATH
+ 1];
145 /* This vector maps GDB's idea of a register's number into an address
146 in the win32 exception context vector.
148 It also contains the bit mask needed to load the register in question.
150 One day we could read a reg, we could inspect the context we
151 already have loaded, if it doesn't have the bit set that we need,
152 we read that set of registers in using GetThreadContext. If the
153 context already contains what we need, we just unpack it. Then to
154 write a register, first we have to ensure that the context contains
155 the other regs of the group, and then we copy the info in and set
158 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
159 static const int mappings
[] =
161 context_offset (Eax
),
162 context_offset (Ecx
),
163 context_offset (Edx
),
164 context_offset (Ebx
),
165 context_offset (Esp
),
166 context_offset (Ebp
),
167 context_offset (Esi
),
168 context_offset (Edi
),
169 context_offset (Eip
),
170 context_offset (EFlags
),
171 context_offset (SegCs
),
172 context_offset (SegSs
),
173 context_offset (SegDs
),
174 context_offset (SegEs
),
175 context_offset (SegFs
),
176 context_offset (SegGs
),
177 context_offset (FloatSave
.RegisterArea
[0 * 10]),
178 context_offset (FloatSave
.RegisterArea
[1 * 10]),
179 context_offset (FloatSave
.RegisterArea
[2 * 10]),
180 context_offset (FloatSave
.RegisterArea
[3 * 10]),
181 context_offset (FloatSave
.RegisterArea
[4 * 10]),
182 context_offset (FloatSave
.RegisterArea
[5 * 10]),
183 context_offset (FloatSave
.RegisterArea
[6 * 10]),
184 context_offset (FloatSave
.RegisterArea
[7 * 10]),
185 context_offset (FloatSave
.ControlWord
),
186 context_offset (FloatSave
.StatusWord
),
187 context_offset (FloatSave
.TagWord
),
188 context_offset (FloatSave
.ErrorSelector
),
189 context_offset (FloatSave
.ErrorOffset
),
190 context_offset (FloatSave
.DataSelector
),
191 context_offset (FloatSave
.DataOffset
),
192 context_offset (FloatSave
.ErrorSelector
)
195 context_offset (ExtendedRegisters
[10*16]),
196 context_offset (ExtendedRegisters
[11*16]),
197 context_offset (ExtendedRegisters
[12*16]),
198 context_offset (ExtendedRegisters
[13*16]),
199 context_offset (ExtendedRegisters
[14*16]),
200 context_offset (ExtendedRegisters
[15*16]),
201 context_offset (ExtendedRegisters
[16*16]),
202 context_offset (ExtendedRegisters
[17*16]),
204 context_offset (ExtendedRegisters
[24])
208 #undef context_offset
210 /* This vector maps the target's idea of an exception (extracted
211 from the DEBUG_EVENT structure) to GDB's idea. */
213 struct xlate_exception
216 enum target_signal us
;
219 static const struct xlate_exception
222 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
223 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
224 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
225 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
226 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
227 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
231 check (BOOL ok
, const char *file
, int line
)
234 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
239 /* Find a thread record given a thread id.
240 If get_context then also retrieve the context for this
243 thread_rec (DWORD id
, int get_context
)
247 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
250 if (!th
->suspend_count
&& get_context
)
252 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
253 th
->suspend_count
= SuspendThread (th
->h
) + 1;
254 else if (get_context
< 0)
255 th
->suspend_count
= -1;
257 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
258 GetThreadContext (th
->h
, &th
->context
);
259 if (id
== current_event
.dwThreadId
)
261 /* Copy dr values from that thread. */
262 dr
[0] = th
->context
.Dr0
;
263 dr
[1] = th
->context
.Dr1
;
264 dr
[2] = th
->context
.Dr2
;
265 dr
[3] = th
->context
.Dr3
;
266 dr
[6] = th
->context
.Dr6
;
267 dr
[7] = th
->context
.Dr7
;
276 /* Add a thread to the thread list */
278 child_add_thread (DWORD id
, HANDLE h
)
282 if ((th
= thread_rec (id
, FALSE
)))
285 th
= (thread_info
*) xmalloc (sizeof (*th
));
286 memset (th
, 0, sizeof (*th
));
289 th
->next
= thread_head
.next
;
290 thread_head
.next
= th
;
291 add_thread (pid_to_ptid (id
));
292 /* Set the debug registers for the new thread in they are used. */
293 if (debug_registers_used
)
295 /* Only change the value of the debug registers. */
296 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
297 CHECK (GetThreadContext (th
->h
, &th
->context
));
298 th
->context
.Dr0
= dr
[0];
299 th
->context
.Dr1
= dr
[1];
300 th
->context
.Dr2
= dr
[2];
301 th
->context
.Dr3
= dr
[3];
302 /* th->context.Dr6 = dr[6];
303 FIXME: should we set dr6 also ?? */
304 th
->context
.Dr7
= dr
[7];
305 CHECK (SetThreadContext (th
->h
, &th
->context
));
306 th
->context
.ContextFlags
= 0;
311 /* Clear out any old thread list and reintialize it to a
314 child_init_thread_list (void)
316 thread_info
*th
= &thread_head
;
318 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
320 while (th
->next
!= NULL
)
322 thread_info
*here
= th
->next
;
323 th
->next
= here
->next
;
324 (void) CloseHandle (here
->h
);
329 /* Delete a thread from the list of threads */
331 child_delete_thread (DWORD id
)
336 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
337 delete_thread (pid_to_ptid (id
));
339 for (th
= &thread_head
;
340 th
->next
!= NULL
&& th
->next
->id
!= id
;
344 if (th
->next
!= NULL
)
346 thread_info
*here
= th
->next
;
347 th
->next
= here
->next
;
348 CloseHandle (here
->h
);
354 do_child_fetch_inferior_registers (int r
)
356 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
360 l
= *((long *) context_offset
) & 0xffff;
361 supply_register (r
, (char *) &l
);
363 else if (r
== FOP_REGNUM
)
365 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
366 supply_register (r
, (char *) &l
);
369 supply_register (r
, context_offset
);
372 for (r
= 0; r
< NUM_REGS
; r
++)
373 do_child_fetch_inferior_registers (r
);
378 child_fetch_inferior_registers (int r
)
380 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
381 do_child_fetch_inferior_registers (r
);
385 do_child_store_inferior_registers (int r
)
388 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
391 for (r
= 0; r
< NUM_REGS
; r
++)
392 do_child_store_inferior_registers (r
);
396 /* Store a new register value into the current thread context */
398 child_store_inferior_registers (int r
)
400 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
401 do_child_store_inferior_registers (r
);
404 static int psapi_loaded
= 0;
405 static HMODULE psapi_module_handle
= NULL
;
406 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
407 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
408 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
411 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
417 HMODULE
*DllHandle
= dh_buf
;
422 psapi_EnumProcessModules
== NULL
||
423 psapi_GetModuleInformation
== NULL
||
424 psapi_GetModuleFileNameExA
== NULL
)
429 psapi_module_handle
= LoadLibrary ("psapi.dll");
430 if (!psapi_module_handle
)
432 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
435 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
436 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
437 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
438 "GetModuleFileNameExA");
439 if (psapi_EnumProcessModules
== NULL
||
440 psapi_GetModuleInformation
== NULL
||
441 psapi_GetModuleFileNameExA
== NULL
)
446 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
451 if (!ok
|| !cbNeeded
)
454 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
458 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
465 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
467 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
471 error ("Can't get module info");
473 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
478 error ("Error getting dll name: %u\n", GetLastError ());
480 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
485 dll_name_ret
[0] = '\0';
489 /* Encapsulate the information required in a call to
490 symbol_file_add_args */
491 struct safe_symbol_file_add_args
495 struct section_addr_info
*addrs
;
498 struct ui_file
*err
, *out
;
502 /* Maintain a linked list of "so" information. */
505 struct so_stuff
*next
;
508 struct objfile
*objfile
;
510 } solib_start
, *solib_end
;
512 /* Call symbol_file_add with stderr redirected. We don't care if there
515 safe_symbol_file_add_stub (void *argv
)
517 #define p ((struct safe_symbol_file_add_args *)argv)
518 struct so_stuff
*so
= &solib_start
;
520 while ((so
= so
->next
))
521 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
523 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
528 /* Restore gdb's stderr after calling symbol_file_add */
530 safe_symbol_file_add_cleanup (void *p
)
532 #define sp ((struct safe_symbol_file_add_args *)p)
533 gdb_flush (gdb_stderr
);
534 gdb_flush (gdb_stdout
);
535 ui_file_delete (gdb_stderr
);
536 ui_file_delete (gdb_stdout
);
537 gdb_stderr
= sp
->err
;
538 gdb_stdout
= sp
->out
;
542 /* symbol_file_add wrapper that prevents errors from being displayed. */
543 static struct objfile
*
544 safe_symbol_file_add (char *name
, int from_tty
,
545 struct section_addr_info
*addrs
,
546 int mainline
, int flags
)
548 struct safe_symbol_file_add_args p
;
549 struct cleanup
*cleanup
;
551 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
555 gdb_flush (gdb_stderr
);
556 gdb_flush (gdb_stdout
);
557 gdb_stderr
= ui_file_new ();
558 gdb_stdout
= ui_file_new ();
560 p
.from_tty
= from_tty
;
562 p
.mainline
= mainline
;
564 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
566 do_cleanups (cleanup
);
570 /* Remember the maximum DLL length for printing in info dll command. */
571 int max_dll_name_len
;
574 register_loaded_dll (const char *name
, DWORD load_addr
)
577 char ppath
[MAX_PATH
+ 1];
578 char buf
[MAX_PATH
+ 1];
579 char cwd
[MAX_PATH
+ 1];
581 WIN32_FIND_DATA w32_fd
;
582 HANDLE h
= FindFirstFile(name
, &w32_fd
);
585 if (h
!= INVALID_HANDLE_VALUE
)
589 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
591 p
= strrchr (buf
, '\\');
594 SetCurrentDirectory (buf
);
595 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
596 SetCurrentDirectory (cwd
);
600 cygwin_conv_to_posix_path (buf
, ppath
);
601 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
603 so
->load_addr
= load_addr
;
606 strcpy (so
->name
, ppath
);
608 solib_end
->next
= so
;
610 len
= strlen (ppath
);
611 if (len
> max_dll_name_len
)
612 max_dll_name_len
= len
;
616 get_image_name (HANDLE h
, void *address
, int unicode
)
618 static char buf
[(2 * MAX_PATH
) + 1];
619 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
625 /* Attempt to read the name of the dll that was detected.
626 This is documented to work only when actively debugging
627 a program. It will not work for attached processes. */
631 ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
);
633 /* See if we could read the address of a string, and that the
634 address isn't null. */
636 if (done
!= sizeof (address_ptr
) || !address_ptr
)
639 /* Find the length of the string */
642 ReadProcessMemory (h
, address_ptr
+ len
* size
, &b
, size
, &done
);
645 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
648 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
651 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
652 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
655 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
661 /* Wait for child to do something. Return pid of child, or -1 in case
662 of error; store status through argument pointer OURSTATUS. */
664 handle_load_dll (void *dummy
)
666 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
667 char dll_buf
[MAX_PATH
+ 1];
668 char *dll_name
= NULL
;
671 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
673 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
674 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
678 if (*dll_name
== '\0')
679 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
683 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
689 handle_unload_dll (void *dummy
)
691 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
694 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
695 if (so
->next
->load_addr
== lpBaseOfDll
)
697 struct so_stuff
*sodel
= so
->next
;
698 so
->next
= sodel
->next
;
702 free_objfile (sodel
->objfile
);
706 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
711 /* Return name of last loaded DLL. */
713 child_solib_loaded_library_pathname (int pid
)
715 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
718 /* Clear list of loaded DLLs. */
720 child_clear_solibs (void)
722 struct so_stuff
*so
, *so1
= solib_start
.next
;
724 while ((so
= so1
) != NULL
)
730 solib_start
.next
= NULL
;
731 solib_start
.objfile
= NULL
;
732 solib_end
= &solib_start
;
733 max_dll_name_len
= sizeof ("DLL Name") - 1;
736 /* Add DLL symbol information. */
737 static struct objfile
*
738 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
740 struct section_addr_info section_addrs
;
742 /* The symbols in a dll are offset by 0x1000, which is the
743 the offset from 0 of the first byte in an image - because
744 of the file header and the section alignment. */
746 if (!name
|| !name
[0])
749 memset (§ion_addrs
, 0, sizeof (section_addrs
));
750 section_addrs
.other
[0].name
= ".text";
751 section_addrs
.other
[0].addr
= load_addr
;
752 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
755 /* Load DLL symbol info. */
757 dll_symbol_command (char *args
, int from_tty
)
763 error ("dll-symbols requires a file name");
766 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
768 char *newargs
= (char *) alloca (n
+ 4 + 1);
769 strcpy (newargs
, args
);
770 strcat (newargs
, ".dll");
774 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
777 /* List currently loaded DLLs. */
779 info_dll_command (char *ignore
, int from_tty
)
781 struct so_stuff
*so
= &solib_start
;
786 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
787 while ((so
= so
->next
) != NULL
)
788 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
793 /* Handle DEBUG_STRING output from child process.
794 Cygwin prepends its messages with a "cygwin:". Interpret this as
795 a Cygwin signal. Otherwise just print the string as a warning. */
797 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
802 if (!target_read_string
803 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
807 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
809 if (strncmp (s
, "cYg", 3) != 0)
815 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
816 gotasig
= target_signal_from_host (sig
);
817 ourstatus
->value
.sig
= gotasig
;
819 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
827 display_selector (HANDLE thread
, DWORD sel
)
830 if (GetThreadSelectorEntry (thread
, sel
, &info
))
833 printf_filtered ("0x%03lx: ", sel
);
834 if (!info
.HighWord
.Bits
.Pres
)
836 puts_filtered ("Segment not present\n");
839 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
840 (info
.HighWord
.Bits
.BaseMid
<< 16)
842 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
843 if (info
.HighWord
.Bits
.Granularity
)
844 limit
= (limit
<< 12) | 0xfff;
845 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
846 if (info
.HighWord
.Bits
.Default_Big
)
847 puts_filtered(" 32-bit ");
849 puts_filtered(" 16-bit ");
850 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
853 puts_filtered ("Data (Read-Only, Exp-up");
856 puts_filtered ("Data (Read/Write, Exp-up");
859 puts_filtered ("Unused segment (");
862 puts_filtered ("Data (Read/Write, Exp-down");
865 puts_filtered ("Code (Exec-Only, N.Conf");
868 puts_filtered ("Code (Exec/Read, N.Conf");
871 puts_filtered ("Code (Exec-Only, Conf");
874 puts_filtered ("Code (Exec/Read, Conf");
877 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
879 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
880 puts_filtered(", N.Acc");
881 puts_filtered (")\n");
882 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
883 puts_filtered("System selector ");
884 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
885 if (info
.HighWord
.Bits
.Granularity
)
886 puts_filtered ("Page granular.\n");
888 puts_filtered ("Byte granular.\n");
893 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
899 display_selectors (char * args
, int from_tty
)
903 puts_filtered ("Impossible to display selectors now.\n");
909 puts_filtered ("Selector $cs\n");
910 display_selector (current_thread
->h
,
911 current_thread
->context
.SegCs
);
912 puts_filtered ("Selector $ds\n");
913 display_selector (current_thread
->h
,
914 current_thread
->context
.SegDs
);
915 puts_filtered ("Selector $es\n");
916 display_selector (current_thread
->h
,
917 current_thread
->context
.SegEs
);
918 puts_filtered ("Selector $ss\n");
919 display_selector (current_thread
->h
,
920 current_thread
->context
.SegSs
);
921 puts_filtered ("Selector $fs\n");
922 display_selector (current_thread
->h
,
923 current_thread
->context
.SegFs
);
924 puts_filtered ("Selector $gs\n");
925 display_selector (current_thread
->h
,
926 current_thread
->context
.SegGs
);
931 sel
= parse_and_eval_long (args
);
932 printf_filtered ("Selector \"%s\"\n",args
);
933 display_selector (current_thread
->h
, sel
);
937 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
940 info_w32_command (char *args
, int from_tty
)
942 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
946 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
947 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
948 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
951 handle_exception (struct target_waitstatus
*ourstatus
)
954 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
956 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
958 /* Record the context of the current thread */
959 th
= thread_rec (current_event
.dwThreadId
, -1);
963 case EXCEPTION_ACCESS_VIOLATION
:
964 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
965 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
967 case STATUS_STACK_OVERFLOW
:
968 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
969 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
971 case STATUS_FLOAT_DENORMAL_OPERAND
:
972 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
973 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
975 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
976 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
977 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
979 case STATUS_FLOAT_INEXACT_RESULT
:
980 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
981 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
983 case STATUS_FLOAT_INVALID_OPERATION
:
984 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
985 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
987 case STATUS_FLOAT_OVERFLOW
:
988 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
989 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
991 case STATUS_FLOAT_STACK_CHECK
:
992 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
993 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
995 case STATUS_FLOAT_UNDERFLOW
:
996 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
997 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
999 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1000 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1001 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1003 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1004 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1005 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1007 case STATUS_INTEGER_OVERFLOW
:
1008 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1009 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1011 case EXCEPTION_BREAKPOINT
:
1012 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1013 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1016 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1017 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1019 case DBG_CONTROL_BREAK
:
1020 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1021 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1023 case EXCEPTION_SINGLE_STEP
:
1024 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1025 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1027 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1028 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1029 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1031 case EXCEPTION_PRIV_INSTRUCTION
:
1032 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1033 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1035 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1036 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1037 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1040 if (current_event
.u
.Exception
.dwFirstChance
)
1042 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1043 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1044 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1045 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1049 last_sig
= ourstatus
->value
.sig
;
1053 /* Resume all artificially suspended threads if we are continuing
1056 child_continue (DWORD continue_status
, int id
)
1062 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1063 current_event
.dwProcessId
, current_event
.dwThreadId
,
1064 continue_status
== DBG_CONTINUE
?
1065 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1066 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1067 current_event
.dwThreadId
,
1069 continue_status
= 0;
1071 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1072 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1075 for (i
= 0; i
< th
->suspend_count
; i
++)
1076 (void) ResumeThread (th
->h
);
1077 th
->suspend_count
= 0;
1078 if (debug_registers_changed
)
1080 /* Only change the value of the debug reisters */
1081 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1082 th
->context
.Dr0
= dr
[0];
1083 th
->context
.Dr1
= dr
[1];
1084 th
->context
.Dr2
= dr
[2];
1085 th
->context
.Dr3
= dr
[3];
1086 /* th->context.Dr6 = dr[6];
1087 FIXME: should we set dr6 also ?? */
1088 th
->context
.Dr7
= dr
[7];
1089 CHECK (SetThreadContext (th
->h
, &th
->context
));
1090 th
->context
.ContextFlags
= 0;
1094 debug_registers_changed
= 0;
1098 /* Get the next event from the child. Return 1 if the event requires
1099 handling by WFI (or whatever).
1102 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1105 DWORD continue_status
, event_code
;
1106 thread_info
*th
= NULL
;
1107 static thread_info dummy_thread_info
;
1110 last_sig
= TARGET_SIGNAL_0
;
1112 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1116 continue_status
= DBG_CONTINUE
;
1118 event_code
= current_event
.dwDebugEventCode
;
1119 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1123 case CREATE_THREAD_DEBUG_EVENT
:
1124 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1125 (unsigned) current_event
.dwProcessId
,
1126 (unsigned) current_event
.dwThreadId
,
1127 "CREATE_THREAD_DEBUG_EVENT"));
1128 if (saw_create
!= 1)
1130 /* Record the existence of this thread */
1131 th
= child_add_thread (current_event
.dwThreadId
,
1132 current_event
.u
.CreateThread
.hThread
);
1134 printf_unfiltered ("[New %s]\n",
1136 pid_to_ptid (current_event
.dwThreadId
)));
1137 retval
= current_event
.dwThreadId
;
1140 case EXIT_THREAD_DEBUG_EVENT
:
1141 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1142 (unsigned) current_event
.dwProcessId
,
1143 (unsigned) current_event
.dwThreadId
,
1144 "EXIT_THREAD_DEBUG_EVENT"));
1145 if (saw_create
!= 1)
1147 child_delete_thread (current_event
.dwThreadId
);
1148 th
= &dummy_thread_info
;
1151 case CREATE_PROCESS_DEBUG_EVENT
:
1152 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1153 (unsigned) current_event
.dwProcessId
,
1154 (unsigned) current_event
.dwThreadId
,
1155 "CREATE_PROCESS_DEBUG_EVENT"));
1156 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1157 if (++saw_create
!= 1)
1159 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1163 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1164 main_thread_id
= current_event
.dwThreadId
;
1165 /* Add the main thread */
1167 th
= child_add_thread (current_event
.dwProcessId
,
1168 current_event
.u
.CreateProcessInfo
.hProcess
);
1170 th
= child_add_thread (main_thread_id
,
1171 current_event
.u
.CreateProcessInfo
.hThread
);
1172 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1175 case EXIT_PROCESS_DEBUG_EVENT
:
1176 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1177 (unsigned) current_event
.dwProcessId
,
1178 (unsigned) current_event
.dwThreadId
,
1179 "EXIT_PROCESS_DEBUG_EVENT"));
1180 if (saw_create
!= 1)
1182 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1183 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1184 CloseHandle (current_process_handle
);
1185 retval
= main_thread_id
;
1188 case LOAD_DLL_DEBUG_EVENT
:
1189 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1190 (unsigned) current_event
.dwProcessId
,
1191 (unsigned) current_event
.dwThreadId
,
1192 "LOAD_DLL_DEBUG_EVENT"));
1193 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1194 if (saw_create
!= 1)
1196 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1197 registers_changed (); /* mark all regs invalid */
1198 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1199 ourstatus
->value
.integer
= 0;
1200 retval
= main_thread_id
;
1203 case UNLOAD_DLL_DEBUG_EVENT
:
1204 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1205 (unsigned) current_event
.dwProcessId
,
1206 (unsigned) current_event
.dwThreadId
,
1207 "UNLOAD_DLL_DEBUG_EVENT"));
1208 if (saw_create
!= 1)
1210 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1211 registers_changed (); /* mark all regs invalid */
1212 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1213 does not exist yet. */
1216 case EXCEPTION_DEBUG_EVENT
:
1217 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1218 (unsigned) current_event
.dwProcessId
,
1219 (unsigned) current_event
.dwThreadId
,
1220 "EXCEPTION_DEBUG_EVENT"));
1221 if (saw_create
!= 1)
1223 if (handle_exception (ourstatus
))
1224 retval
= current_event
.dwThreadId
;
1227 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1228 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1229 (unsigned) current_event
.dwProcessId
,
1230 (unsigned) current_event
.dwThreadId
,
1231 "OUTPUT_DEBUG_STRING_EVENT"));
1232 if (saw_create
!= 1)
1234 if (handle_output_debug_string (ourstatus
))
1235 retval
= main_thread_id
;
1239 if (saw_create
!= 1)
1241 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1242 (DWORD
) current_event
.dwProcessId
,
1243 (DWORD
) current_event
.dwThreadId
);
1244 printf_unfiltered (" unknown event code %ld\n",
1245 current_event
.dwDebugEventCode
);
1249 if (!retval
|| saw_create
!= 1)
1250 CHECK (child_continue (continue_status
, -1));
1253 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1254 inferior_ptid
= pid_to_ptid (retval
);
1261 /* Wait for interesting events to occur in the target process. */
1263 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1265 int pid
= PIDGET (ptid
);
1267 /* We loop when we get a non-standard exception rather than return
1268 with a SPURIOUS because resume can try and step or modify things,
1269 which needs a current_thread->h. But some of these exceptions mark
1270 the birth or death of threads, which mean that the current thread
1271 isn't necessarily what you think it is. */
1275 int retval
= get_child_debug_event (pid
, ourstatus
);
1277 return pid_to_ptid (retval
);
1282 if (ui_loop_hook
!= NULL
)
1283 detach
= ui_loop_hook (0);
1286 child_kill_inferior ();
1292 do_initial_child_stuff (DWORD pid
)
1294 extern int stop_after_trap
;
1297 last_sig
= TARGET_SIGNAL_0
;
1299 exception_count
= 0;
1300 debug_registers_changed
= 0;
1301 debug_registers_used
= 0;
1302 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1304 current_event
.dwProcessId
= pid
;
1305 memset (¤t_event
, 0, sizeof (current_event
));
1306 push_target (&child_ops
);
1307 child_init_thread_list ();
1308 child_clear_solibs ();
1309 clear_proceed_status ();
1310 init_wait_for_inferior ();
1312 target_terminal_init ();
1313 target_terminal_inferior ();
1317 stop_after_trap
= 1;
1318 wait_for_inferior ();
1319 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1320 resume (0, stop_signal
);
1324 stop_after_trap
= 0;
1328 /* Since Windows XP, detaching from a process is supported by Windows.
1329 The following code tries loading the appropriate functions dynamically.
1330 If loading these functions succeeds use them to actually detach from
1331 the inferior process, otherwise behave as usual, pretending that
1332 detach has worked. */
1333 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1334 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1337 has_detach_ability ()
1339 static HMODULE kernel32
= NULL
;
1342 kernel32
= LoadLibrary ("kernel32.dll");
1345 if (!DebugSetProcessKillOnExit
)
1346 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1347 "DebugSetProcessKillOnExit");
1348 if (!DebugActiveProcessStop
)
1349 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1350 "DebugActiveProcessStop");
1351 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1357 /* Attach to process PID, then initialize for debugging it. */
1359 child_attach (char *args
, int from_tty
)
1365 error_no_arg ("process-id to attach");
1367 pid
= strtoul (args
, 0, 0);
1368 ok
= DebugActiveProcess (pid
);
1371 error ("Can't attach to process.");
1373 if (has_detach_ability ())
1376 DebugSetProcessKillOnExit (FALSE
);
1381 char *exec_file
= (char *) get_exec_file (0);
1384 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1385 target_pid_to_str (pid_to_ptid (pid
)));
1387 printf_unfiltered ("Attaching to %s\n",
1388 target_pid_to_str (pid_to_ptid (pid
)));
1390 gdb_flush (gdb_stdout
);
1393 do_initial_child_stuff (pid
);
1394 target_terminal_ours ();
1398 child_detach (char *args
, int from_tty
)
1402 if (has_detach_ability ())
1404 delete_command (NULL
, 0);
1405 child_continue (DBG_CONTINUE
, -1);
1406 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1408 error ("Can't detach process %lu (error %lu)",
1409 current_event
.dwProcessId
, GetLastError ());
1412 DebugSetProcessKillOnExit (FALSE
);
1414 if (detached
&& from_tty
)
1416 char *exec_file
= get_exec_file (0);
1419 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1420 current_event
.dwProcessId
);
1421 gdb_flush (gdb_stdout
);
1423 inferior_ptid
= null_ptid
;
1424 unpush_target (&child_ops
);
1427 /* Print status information about what we're accessing. */
1430 child_files_info (struct target_ops
*ignore
)
1432 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1433 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1438 child_open (char *arg
, int from_tty
)
1440 error ("Use the \"run\" command to start a Unix child process.");
1443 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1444 EXEC_FILE is the file to run.
1445 ALLARGS is a string containing the arguments to the program.
1446 ENV is the environment vector to pass. Errors reported with error(). */
1449 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1456 PROCESS_INFORMATION pi
;
1460 char real_path
[MAXPATHLEN
];
1464 error ("No executable specified, use `target exec'.\n");
1466 memset (&si
, 0, sizeof (si
));
1467 si
.cb
= sizeof (si
);
1472 flags
|= CREATE_NEW_PROCESS_GROUP
;
1475 flags
|= CREATE_NEW_CONSOLE
;
1477 if (!useshell
|| !shell
[0])
1479 flags
= DEBUG_ONLY_THIS_PROCESS
;
1480 cygwin_conv_to_win32_path (exec_file
, real_path
);
1485 char *newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
) + strlen (allargs
) + 2);
1486 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1487 allargs
= newallargs
;
1489 flags
= DEBUG_PROCESS
;
1492 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1493 strcpy (args
, toexec
);
1495 strcat (args
, allargs
);
1497 /* Prepare the environment vars for CreateProcess. */
1499 /* This code use to assume all env vars were file names and would
1500 translate them all to win32 style. That obviously doesn't work in the
1501 general case. The current rule is that we only translate PATH.
1502 We need to handle PATH because we're about to call CreateProcess and
1503 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1504 in both posix and win32 environments. cygwin.dll will change it back
1505 to posix style if necessary. */
1507 static const char *conv_path_names
[] =
1513 /* CreateProcess takes the environment list as a null terminated set of
1514 strings (i.e. two nulls terminate the list). */
1516 /* Get total size for env strings. */
1517 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1521 for (j
= 0; conv_path_names
[j
]; j
++)
1523 len
= strlen (conv_path_names
[j
]);
1524 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1526 if (cygwin_posix_path_list_p (env
[i
] + len
))
1528 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1530 envlen
+= strlen (env
[i
]) + 1;
1534 if (conv_path_names
[j
] == NULL
)
1535 envlen
+= strlen (env
[i
]) + 1;
1538 winenv
= alloca (envlen
+ 1);
1540 /* Copy env strings into new buffer. */
1541 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1545 for (j
= 0; conv_path_names
[j
]; j
++)
1547 len
= strlen (conv_path_names
[j
]);
1548 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1550 if (cygwin_posix_path_list_p (env
[i
] + len
))
1552 memcpy (temp
, env
[i
], len
);
1553 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1556 strcpy (temp
, env
[i
]);
1560 if (conv_path_names
[j
] == NULL
)
1561 strcpy (temp
, env
[i
]);
1563 temp
+= strlen (temp
) + 1;
1566 /* Final nil string to terminate new env. */
1570 ret
= CreateProcess (0,
1571 args
, /* command line */
1572 NULL
, /* Security */
1574 TRUE
, /* inherit handles */
1575 flags
, /* start flags */
1577 NULL
, /* current directory */
1581 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1583 CloseHandle (pi
.hThread
);
1584 CloseHandle (pi
.hProcess
);
1586 if (useshell
&& shell
[0] != '\0')
1591 do_initial_child_stuff (pi
.dwProcessId
);
1593 /* child_continue (DBG_CONTINUE, -1); */
1594 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1598 child_mourn_inferior (void)
1600 (void) child_continue (DBG_CONTINUE
, -1);
1601 i386_cleanup_dregs();
1602 unpush_target (&child_ops
);
1603 generic_mourn_inferior ();
1606 /* Send a SIGINT to the process group. This acts just like the user typed a
1607 ^C on the controlling terminal. */
1612 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1613 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1614 registers_changed (); /* refresh register state */
1618 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1619 int write
, struct mem_attrib
*mem
,
1620 struct target_ops
*target
)
1625 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1626 len
, (DWORD
) memaddr
));
1627 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1629 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1633 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1634 len
, (DWORD
) memaddr
));
1635 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1642 child_kill_inferior (void)
1644 CHECK (TerminateProcess (current_process_handle
, 0));
1648 if (!child_continue (DBG_CONTINUE
, -1))
1650 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1652 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1656 CHECK (CloseHandle (current_process_handle
));
1658 /* this may fail in an attached process so don't check. */
1659 (void) CloseHandle (current_thread
->h
);
1660 target_mourn_inferior (); /* or just child_mourn_inferior? */
1664 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1667 DWORD continue_status
= DBG_CONTINUE
;
1669 int pid
= PIDGET (ptid
);
1671 if (sig
!= TARGET_SIGNAL_0
)
1673 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1675 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1677 else if (sig
== last_sig
)
1678 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1681 /* This code does not seem to work, because
1682 the kernel does probably not consider changes in the ExceptionRecord
1683 structure when passing the exception to the inferior.
1684 Note that this seems possible in the exception handler itself. */
1687 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1688 if (xlate
[i
].us
== sig
)
1690 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1692 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1695 if (continue_status
== DBG_CONTINUE
)
1697 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1701 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1705 last_sig
= TARGET_SIGNAL_0
;
1707 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1710 /* Get context for currently selected thread */
1711 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1716 /* Single step by setting t bit */
1717 child_fetch_inferior_registers (PS_REGNUM
);
1718 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1721 if (th
->context
.ContextFlags
)
1723 if (debug_registers_changed
)
1725 th
->context
.Dr0
= dr
[0];
1726 th
->context
.Dr1
= dr
[1];
1727 th
->context
.Dr2
= dr
[2];
1728 th
->context
.Dr3
= dr
[3];
1729 /* th->context.Dr6 = dr[6];
1730 FIXME: should we set dr6 also ?? */
1731 th
->context
.Dr7
= dr
[7];
1733 CHECK (SetThreadContext (th
->h
, &th
->context
));
1734 th
->context
.ContextFlags
= 0;
1738 /* Allow continuing with the same signal that interrupted us.
1739 Otherwise complain. */
1741 child_continue (continue_status
, pid
);
1745 child_prepare_to_store (void)
1747 /* Do nothing, since we can store individual regs */
1751 child_can_run (void)
1759 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1760 PIDGET (inferior_ptid
)));
1763 struct target_ops child_ops
;
1766 init_child_ops (void)
1768 child_ops
.to_shortname
= "child";
1769 child_ops
.to_longname
= "Win32 child process";
1770 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1771 child_ops
.to_open
= child_open
;
1772 child_ops
.to_close
= child_close
;
1773 child_ops
.to_attach
= child_attach
;
1774 child_ops
.to_detach
= child_detach
;
1775 child_ops
.to_resume
= child_resume
;
1776 child_ops
.to_wait
= child_wait
;
1777 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1778 child_ops
.to_store_registers
= child_store_inferior_registers
;
1779 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1780 child_ops
.to_xfer_memory
= child_xfer_memory
;
1781 child_ops
.to_files_info
= child_files_info
;
1782 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1783 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1784 child_ops
.to_terminal_init
= terminal_init_inferior
;
1785 child_ops
.to_terminal_inferior
= terminal_inferior
;
1786 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1787 child_ops
.to_terminal_ours
= terminal_ours
;
1788 child_ops
.to_terminal_info
= child_terminal_info
;
1789 child_ops
.to_kill
= child_kill_inferior
;
1790 child_ops
.to_load
= 0;
1791 child_ops
.to_lookup_symbol
= 0;
1792 child_ops
.to_create_inferior
= child_create_inferior
;
1793 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1794 child_ops
.to_can_run
= child_can_run
;
1795 child_ops
.to_notice_signals
= 0;
1796 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1797 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1798 child_ops
.to_stop
= child_stop
;
1799 child_ops
.to_stratum
= process_stratum
;
1800 child_ops
.DONT_USE
= 0;
1801 child_ops
.to_has_all_memory
= 1;
1802 child_ops
.to_has_memory
= 1;
1803 child_ops
.to_has_stack
= 1;
1804 child_ops
.to_has_registers
= 1;
1805 child_ops
.to_has_execution
= 1;
1806 child_ops
.to_sections
= 0;
1807 child_ops
.to_sections_end
= 0;
1808 child_ops
.to_magic
= OPS_MAGIC
;
1812 _initialize_inftarg (void)
1814 struct cmd_list_element
*c
;
1819 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1820 "Load dll library symbols from FILE.");
1821 c
->completer
= filename_completer
;
1823 sh
= getenv ("SHELL");
1826 if (access (sh
, X_OK
) != 0)
1833 cygwin_conv_to_win32_path (sh
, shell
);
1837 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1839 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
1841 "Set use of shell to start subprocess.",
1845 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1846 (char *) &new_console
,
1847 "Set creation of new console when creating child process.",
1851 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1852 (char *) &new_group
,
1853 "Set creation of new group when creating child process.",
1857 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1858 (char *) &debug_exec
,
1859 "Set whether to display execution in child process.",
1863 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1864 (char *) &debug_events
,
1865 "Set whether to display kernel events in child process.",
1869 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1870 (char *) &debug_memory
,
1871 "Set whether to display memory accesses in child process.",
1875 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1876 (char *) &debug_exceptions
,
1877 "Set whether to display kernel exceptions in child process.",
1881 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1882 add_info_alias ("sharedlibrary", "dll", 1);
1884 add_prefix_cmd ("w32", class_info
, info_w32_command
,
1885 "Print information specific to Win32 debugging.",
1886 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
1888 add_cmd ("selector", class_info
, display_selectors
,
1889 "Display selectors infos.",
1892 add_target (&child_ops
);
1895 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1897 /* Pass the address ADDR to the inferior in the I'th debug register.
1898 Here we just store the address in dr array, the registers will be
1899 actually set up when child_continue is called. */
1901 cygwin_set_dr (int i
, CORE_ADDR addr
)
1904 internal_error (__FILE__
, __LINE__
,
1905 "Invalid register %d in cygwin_set_dr.\n", i
);
1906 dr
[i
] = (unsigned) addr
;
1907 debug_registers_changed
= 1;
1908 debug_registers_used
= 1;
1911 /* Pass the value VAL to the inferior in the DR7 debug control
1912 register. Here we just store the address in D_REGS, the watchpoint
1913 will be actually set up in child_wait. */
1915 cygwin_set_dr7 (unsigned val
)
1918 debug_registers_changed
= 1;
1919 debug_registers_used
= 1;
1922 /* Get the value of the DR6 debug status register from the inferior.
1923 Here we just return the value stored in dr[6]
1924 by the last call to thread_rec for current_event.dwThreadId id. */
1926 cygwin_get_dr6 (void)
1932 /* Determine if the thread referenced by "pid" is alive
1933 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1934 it means that the pid has died. Otherwise it is assumed to be alive. */
1936 win32_child_thread_alive (ptid_t ptid
)
1938 int pid
= PIDGET (ptid
);
1940 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1944 /* Convert pid to printable format. */
1946 cygwin_pid_to_str (ptid_t ptid
)
1948 static char buf
[80];
1949 int pid
= PIDGET (ptid
);
1951 if ((DWORD
) pid
== current_event
.dwProcessId
)
1952 sprintf (buf
, "process %d", pid
);
1954 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1959 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1961 struct objfile
*objfile
;
1962 char *objfile_basename
;
1963 const char *dll_basename
;
1965 if (!(dll_basename
= strrchr (dll_name
, '/')))
1966 dll_basename
= dll_name
;
1970 ALL_OBJFILES (objfile
)
1972 objfile_basename
= strrchr (objfile
->name
, '/');
1974 if (objfile_basename
&&
1975 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1977 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1978 base_addr
, dll_name
);
1983 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1984 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1992 struct target_ops
*target
;
1995 map_code_section_args
;
1998 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2002 struct section_table
*new_target_sect_ptr
;
2004 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2005 struct target_ops
*target
= args
->target
;
2006 if (sect
->flags
& SEC_CODE
)
2008 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2010 if (target
->to_sections
)
2012 old
= target
->to_sections_end
- target
->to_sections
;
2013 target
->to_sections
= (struct section_table
*)
2014 xrealloc ((char *) target
->to_sections
,
2015 (sizeof (struct section_table
)) * (1 + old
));
2020 target
->to_sections
= (struct section_table
*)
2021 xmalloc ((sizeof (struct section_table
)));
2023 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2025 /* Update the to_sections field in the core_ops structure
2029 core_ops
.to_sections
= target
->to_sections
;
2030 core_ops
.to_sections_end
= target
->to_sections_end
;
2032 new_target_sect_ptr
= target
->to_sections
+ old
;
2033 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2034 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2035 bfd_section_size (abfd
, sect
);;
2036 new_target_sect_ptr
->the_bfd_section
= sect
;
2037 new_target_sect_ptr
->bfd
= abfd
;
2042 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2045 map_code_section_args map_args
;
2046 asection
*lowest_sect
;
2048 if (dll_name
== NULL
|| target
== NULL
)
2050 name
= xstrdup (dll_name
);
2051 dll_bfd
= bfd_openr (name
, "pei-i386");
2052 if (dll_bfd
== NULL
)
2055 if (bfd_check_format (dll_bfd
, bfd_object
))
2057 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2058 if (lowest_sect
== NULL
)
2060 map_args
.target
= target
;
2061 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2063 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2070 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2072 struct target_ops
*target
= (struct target_ops
*) obj
;
2077 char *dll_name
= NULL
;
2079 struct win32_pstatus
*pstatus
;
2082 if (strncmp (sect
->name
, ".module", 7))
2085 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2088 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2091 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2094 pstatus
= (struct win32_pstatus
*) buf
;
2096 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2097 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2098 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2101 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2104 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2107 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2109 while ((p
= strchr (dll_name
, '\\')))
2112 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2113 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2115 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2116 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2127 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2134 child_clear_solibs ();
2135 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2139 if (solib_end
&& solib_end
->name
)
2140 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2141 solib_end
->load_addr
);
2146 fetch_elf_core_registers (char *core_reg_sect
,
2147 unsigned core_reg_size
,
2152 if (core_reg_size
< sizeof (CONTEXT
))
2154 error ("Core file register section too small (%u bytes).", core_reg_size
);
2157 for (r
= 0; r
< NUM_REGS
; r
++)
2158 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2161 static struct core_fns win32_elf_core_fns
=
2163 bfd_target_elf_flavour
,
2164 default_check_format
,
2165 default_core_sniffer
,
2166 fetch_elf_core_registers
,
2171 _initialize_core_win32 (void)
2173 add_core_fns (&win32_elf_core_fns
);
2177 _initialize_check_for_gdb_ini (void)
2180 if (inhibit_gdbinit
)
2183 homedir
= getenv ("HOME");
2187 char *oldini
= (char *) alloca (strlen (homedir
) +
2188 sizeof ("/gdb.ini"));
2189 strcpy (oldini
, homedir
);
2190 p
= strchr (oldini
, '\0');
2191 if (p
> oldini
&& p
[-1] != '/')
2193 strcpy (p
, "gdb.ini");
2194 if (access (oldini
, 0) == 0)
2196 int len
= strlen (oldini
);
2197 char *newini
= alloca (len
+ 1);
2198 sprintf (newini
, "%.*s.gdbinit",
2199 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2200 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);