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 */
127 static pid_t cygwin_pid
; /* pid of cygwin process */
129 /* Counts of things. */
130 static int exception_count
= 0;
131 static int event_count
= 0;
132 static int saw_create
;
135 static int new_console
= 0;
136 static int new_group
= 1;
137 static int debug_exec
= 0; /* show execution */
138 static int debug_events
= 0; /* show events from kernel */
139 static int debug_memory
= 0; /* show target memory accesses */
140 static int debug_exceptions
= 0; /* show target exceptions */
141 static int useshell
= 0; /* use shell for subprocesses */
143 /* This vector maps GDB's idea of a register's number into an address
144 in the win32 exception context vector.
146 It also contains the bit mask needed to load the register in question.
148 One day we could read a reg, we could inspect the context we
149 already have loaded, if it doesn't have the bit set that we need,
150 we read that set of registers in using GetThreadContext. If the
151 context already contains what we need, we just unpack it. Then to
152 write a register, first we have to ensure that the context contains
153 the other regs of the group, and then we copy the info in and set
156 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
157 static const int mappings
[] =
159 context_offset (Eax
),
160 context_offset (Ecx
),
161 context_offset (Edx
),
162 context_offset (Ebx
),
163 context_offset (Esp
),
164 context_offset (Ebp
),
165 context_offset (Esi
),
166 context_offset (Edi
),
167 context_offset (Eip
),
168 context_offset (EFlags
),
169 context_offset (SegCs
),
170 context_offset (SegSs
),
171 context_offset (SegDs
),
172 context_offset (SegEs
),
173 context_offset (SegFs
),
174 context_offset (SegGs
),
175 context_offset (FloatSave
.RegisterArea
[0 * 10]),
176 context_offset (FloatSave
.RegisterArea
[1 * 10]),
177 context_offset (FloatSave
.RegisterArea
[2 * 10]),
178 context_offset (FloatSave
.RegisterArea
[3 * 10]),
179 context_offset (FloatSave
.RegisterArea
[4 * 10]),
180 context_offset (FloatSave
.RegisterArea
[5 * 10]),
181 context_offset (FloatSave
.RegisterArea
[6 * 10]),
182 context_offset (FloatSave
.RegisterArea
[7 * 10]),
183 context_offset (FloatSave
.ControlWord
),
184 context_offset (FloatSave
.StatusWord
),
185 context_offset (FloatSave
.TagWord
),
186 context_offset (FloatSave
.ErrorSelector
),
187 context_offset (FloatSave
.ErrorOffset
),
188 context_offset (FloatSave
.DataSelector
),
189 context_offset (FloatSave
.DataOffset
),
190 context_offset (FloatSave
.ErrorSelector
)
193 context_offset (ExtendedRegisters
[10*16]),
194 context_offset (ExtendedRegisters
[11*16]),
195 context_offset (ExtendedRegisters
[12*16]),
196 context_offset (ExtendedRegisters
[13*16]),
197 context_offset (ExtendedRegisters
[14*16]),
198 context_offset (ExtendedRegisters
[15*16]),
199 context_offset (ExtendedRegisters
[16*16]),
200 context_offset (ExtendedRegisters
[17*16]),
202 context_offset (ExtendedRegisters
[24])
206 #undef context_offset
208 /* This vector maps the target's idea of an exception (extracted
209 from the DEBUG_EVENT structure) to GDB's idea. */
211 struct xlate_exception
214 enum target_signal us
;
217 static const struct xlate_exception
220 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
221 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
222 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
223 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
224 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
225 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
229 check (BOOL ok
, const char *file
, int line
)
232 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
237 /* Find a thread record given a thread id.
238 If get_context then also retrieve the context for this
241 thread_rec (DWORD id
, int get_context
)
245 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
248 if (!th
->suspend_count
&& get_context
)
250 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
251 th
->suspend_count
= SuspendThread (th
->h
) + 1;
252 else if (get_context
< 0)
253 th
->suspend_count
= -1;
255 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
256 GetThreadContext (th
->h
, &th
->context
);
257 if (id
== current_event
.dwThreadId
)
259 /* Copy dr values from that thread. */
260 dr
[0] = th
->context
.Dr0
;
261 dr
[1] = th
->context
.Dr1
;
262 dr
[2] = th
->context
.Dr2
;
263 dr
[3] = th
->context
.Dr3
;
264 dr
[6] = th
->context
.Dr6
;
265 dr
[7] = th
->context
.Dr7
;
274 /* Add a thread to the thread list */
276 child_add_thread (DWORD id
, HANDLE h
)
280 if ((th
= thread_rec (id
, FALSE
)))
283 th
= (thread_info
*) xmalloc (sizeof (*th
));
284 memset (th
, 0, sizeof (*th
));
287 th
->next
= thread_head
.next
;
288 thread_head
.next
= th
;
289 add_thread (pid_to_ptid (id
));
290 /* Set the debug registers for the new thread in they are used. */
291 if (debug_registers_used
)
293 /* Only change the value of the debug registers. */
294 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
295 CHECK (GetThreadContext (th
->h
, &th
->context
));
296 th
->context
.Dr0
= dr
[0];
297 th
->context
.Dr1
= dr
[1];
298 th
->context
.Dr2
= dr
[2];
299 th
->context
.Dr3
= dr
[3];
300 /* th->context.Dr6 = dr[6];
301 FIXME: should we set dr6 also ?? */
302 th
->context
.Dr7
= dr
[7];
303 CHECK (SetThreadContext (th
->h
, &th
->context
));
304 th
->context
.ContextFlags
= 0;
309 /* Clear out any old thread list and reintialize it to a
312 child_init_thread_list (void)
314 thread_info
*th
= &thread_head
;
316 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
318 while (th
->next
!= NULL
)
320 thread_info
*here
= th
->next
;
321 th
->next
= here
->next
;
322 (void) CloseHandle (here
->h
);
327 /* Delete a thread from the list of threads */
329 child_delete_thread (DWORD id
)
334 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
335 delete_thread (pid_to_ptid (id
));
337 for (th
= &thread_head
;
338 th
->next
!= NULL
&& th
->next
->id
!= id
;
342 if (th
->next
!= NULL
)
344 thread_info
*here
= th
->next
;
345 th
->next
= here
->next
;
346 CloseHandle (here
->h
);
352 do_child_fetch_inferior_registers (int r
)
354 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
358 l
= *((long *) context_offset
) & 0xffff;
359 supply_register (r
, (char *) &l
);
361 else if (r
== FOP_REGNUM
)
363 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
364 supply_register (r
, (char *) &l
);
367 supply_register (r
, context_offset
);
370 for (r
= 0; r
< NUM_REGS
; r
++)
371 do_child_fetch_inferior_registers (r
);
376 child_fetch_inferior_registers (int r
)
378 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
379 do_child_fetch_inferior_registers (r
);
383 do_child_store_inferior_registers (int r
)
386 deprecated_read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
389 for (r
= 0; r
< NUM_REGS
; r
++)
390 do_child_store_inferior_registers (r
);
394 /* Store a new register value into the current thread context */
396 child_store_inferior_registers (int r
)
398 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
399 do_child_store_inferior_registers (r
);
402 static int psapi_loaded
= 0;
403 static HMODULE psapi_module_handle
= NULL
;
404 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
405 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
406 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
409 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
415 HMODULE
*DllHandle
= dh_buf
;
420 psapi_EnumProcessModules
== NULL
||
421 psapi_GetModuleInformation
== NULL
||
422 psapi_GetModuleFileNameExA
== NULL
)
427 psapi_module_handle
= LoadLibrary ("psapi.dll");
428 if (!psapi_module_handle
)
430 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
433 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
434 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
435 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
436 "GetModuleFileNameExA");
437 if (psapi_EnumProcessModules
== NULL
||
438 psapi_GetModuleInformation
== NULL
||
439 psapi_GetModuleFileNameExA
== NULL
)
444 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
449 if (!ok
|| !cbNeeded
)
452 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
456 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
463 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
465 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
469 error ("Can't get module info");
471 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
476 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
478 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
483 dll_name_ret
[0] = '\0';
487 /* Encapsulate the information required in a call to
488 symbol_file_add_args */
489 struct safe_symbol_file_add_args
493 struct section_addr_info
*addrs
;
496 struct ui_file
*err
, *out
;
500 /* Maintain a linked list of "so" information. */
503 struct so_stuff
*next
;
507 struct objfile
*objfile
;
509 } solib_start
, *solib_end
;
511 /* Call symbol_file_add with stderr redirected. We don't care if there
514 safe_symbol_file_add_stub (void *argv
)
516 #define p ((struct safe_symbol_file_add_args *)argv)
517 struct so_stuff
*so
= &solib_start
;
519 while ((so
= so
->next
))
520 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
522 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
527 /* Restore gdb's stderr after calling symbol_file_add */
529 safe_symbol_file_add_cleanup (void *p
)
531 #define sp ((struct safe_symbol_file_add_args *)p)
532 gdb_flush (gdb_stderr
);
533 gdb_flush (gdb_stdout
);
534 ui_file_delete (gdb_stderr
);
535 ui_file_delete (gdb_stdout
);
536 gdb_stderr
= sp
->err
;
537 gdb_stdout
= sp
->out
;
541 /* symbol_file_add wrapper that prevents errors from being displayed. */
542 static struct objfile
*
543 safe_symbol_file_add (char *name
, int from_tty
,
544 struct section_addr_info
*addrs
,
545 int mainline
, int flags
)
547 struct safe_symbol_file_add_args p
;
548 struct cleanup
*cleanup
;
550 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
554 gdb_flush (gdb_stderr
);
555 gdb_flush (gdb_stdout
);
556 gdb_stderr
= ui_file_new ();
557 gdb_stdout
= ui_file_new ();
559 p
.from_tty
= from_tty
;
561 p
.mainline
= mainline
;
563 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
565 do_cleanups (cleanup
);
569 /* Remember the maximum DLL length for printing in info dll command. */
570 int max_dll_name_len
;
573 register_loaded_dll (const char *name
, DWORD load_addr
)
576 char ppath
[MAX_PATH
+ 1];
577 char buf
[MAX_PATH
+ 1];
578 char cwd
[MAX_PATH
+ 1];
580 WIN32_FIND_DATA w32_fd
;
581 HANDLE h
= FindFirstFile(name
, &w32_fd
);
582 MEMORY_BASIC_INFORMATION m
;
585 if (h
== INVALID_HANDLE_VALUE
)
591 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
593 p
= strrchr (buf
, '\\');
596 SetCurrentDirectory (buf
);
597 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
598 SetCurrentDirectory (cwd
);
602 cygwin_conv_to_posix_path (buf
, ppath
);
603 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
605 so
->load_addr
= load_addr
;
606 if (!VirtualQueryEx (current_process_handle
, (void *) load_addr
, &m
,
608 so
->end_addr
= (DWORD
) m
.AllocationBase
+ m
.RegionSize
;
610 so
->end_addr
= load_addr
+ 0x2000; /* completely arbitrary */
614 strcpy (so
->name
, ppath
);
616 solib_end
->next
= so
;
618 len
= strlen (ppath
);
619 if (len
> max_dll_name_len
)
620 max_dll_name_len
= len
;
624 get_image_name (HANDLE h
, void *address
, int unicode
)
626 static char buf
[(2 * MAX_PATH
) + 1];
627 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
633 /* Attempt to read the name of the dll that was detected.
634 This is documented to work only when actively debugging
635 a program. It will not work for attached processes. */
639 ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
);
641 /* See if we could read the address of a string, and that the
642 address isn't null. */
644 if (done
!= sizeof (address_ptr
) || !address_ptr
)
647 /* Find the length of the string */
650 ReadProcessMemory (h
, address_ptr
+ len
* size
, &b
, size
, &done
);
653 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
656 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
659 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
660 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
663 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
669 /* Wait for child to do something. Return pid of child, or -1 in case
670 of error; store status through argument pointer OURSTATUS. */
672 handle_load_dll (void *dummy
)
674 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
675 char dll_buf
[MAX_PATH
+ 1];
676 char *dll_name
= NULL
;
679 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
681 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
682 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
686 if (*dll_name
== '\0')
687 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
691 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
697 handle_unload_dll (void *dummy
)
699 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
702 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
703 if (so
->next
->load_addr
== lpBaseOfDll
)
705 struct so_stuff
*sodel
= so
->next
;
706 so
->next
= sodel
->next
;
710 free_objfile (sodel
->objfile
);
714 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
720 solib_address (CORE_ADDR address
)
723 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
724 if (address
>= so
->load_addr
&& address
<= so
->end_addr
)
729 /* Return name of last loaded DLL. */
731 child_solib_loaded_library_pathname (int pid
)
733 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
736 /* Clear list of loaded DLLs. */
738 child_clear_solibs (void)
740 struct so_stuff
*so
, *so1
= solib_start
.next
;
742 while ((so
= so1
) != NULL
)
748 solib_start
.next
= NULL
;
749 solib_start
.objfile
= NULL
;
750 solib_end
= &solib_start
;
751 max_dll_name_len
= sizeof ("DLL Name") - 1;
754 /* Add DLL symbol information. */
755 static struct objfile
*
756 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
758 struct section_addr_info section_addrs
;
760 /* The symbols in a dll are offset by 0x1000, which is the
761 the offset from 0 of the first byte in an image - because
762 of the file header and the section alignment. */
764 if (!name
|| !name
[0])
767 memset (§ion_addrs
, 0, sizeof (section_addrs
));
768 section_addrs
.other
[0].name
= ".text";
769 section_addrs
.other
[0].addr
= load_addr
;
770 return safe_symbol_file_add (name
, from_tty
, §ion_addrs
, 0, OBJF_SHARED
);
773 /* Load DLL symbol info. */
775 dll_symbol_command (char *args
, int from_tty
)
781 error ("dll-symbols requires a file name");
784 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
786 char *newargs
= (char *) alloca (n
+ 4 + 1);
787 strcpy (newargs
, args
);
788 strcat (newargs
, ".dll");
792 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
795 /* List currently loaded DLLs. */
797 info_dll_command (char *ignore
, int from_tty
)
799 struct so_stuff
*so
= &solib_start
;
804 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
805 while ((so
= so
->next
) != NULL
)
806 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
811 /* Handle DEBUG_STRING output from child process.
812 Cygwin prepends its messages with a "cygwin:". Interpret this as
813 a Cygwin signal. Otherwise just print the string as a warning. */
815 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
820 if (!target_read_string
821 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
825 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
827 if (strncmp (s
, "cYg", 3) != 0)
833 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
834 gotasig
= target_signal_from_host (sig
);
835 ourstatus
->value
.sig
= gotasig
;
837 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
845 display_selector (HANDLE thread
, DWORD sel
)
848 if (GetThreadSelectorEntry (thread
, sel
, &info
))
851 printf_filtered ("0x%03lx: ", sel
);
852 if (!info
.HighWord
.Bits
.Pres
)
854 puts_filtered ("Segment not present\n");
857 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
858 (info
.HighWord
.Bits
.BaseMid
<< 16)
860 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
861 if (info
.HighWord
.Bits
.Granularity
)
862 limit
= (limit
<< 12) | 0xfff;
863 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
864 if (info
.HighWord
.Bits
.Default_Big
)
865 puts_filtered(" 32-bit ");
867 puts_filtered(" 16-bit ");
868 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
871 puts_filtered ("Data (Read-Only, Exp-up");
874 puts_filtered ("Data (Read/Write, Exp-up");
877 puts_filtered ("Unused segment (");
880 puts_filtered ("Data (Read/Write, Exp-down");
883 puts_filtered ("Code (Exec-Only, N.Conf");
886 puts_filtered ("Code (Exec/Read, N.Conf");
889 puts_filtered ("Code (Exec-Only, Conf");
892 puts_filtered ("Code (Exec/Read, Conf");
895 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
897 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
898 puts_filtered(", N.Acc");
899 puts_filtered (")\n");
900 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
901 puts_filtered("System selector ");
902 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
903 if (info
.HighWord
.Bits
.Granularity
)
904 puts_filtered ("Page granular.\n");
906 puts_filtered ("Byte granular.\n");
911 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
917 display_selectors (char * args
, int from_tty
)
921 puts_filtered ("Impossible to display selectors now.\n");
927 puts_filtered ("Selector $cs\n");
928 display_selector (current_thread
->h
,
929 current_thread
->context
.SegCs
);
930 puts_filtered ("Selector $ds\n");
931 display_selector (current_thread
->h
,
932 current_thread
->context
.SegDs
);
933 puts_filtered ("Selector $es\n");
934 display_selector (current_thread
->h
,
935 current_thread
->context
.SegEs
);
936 puts_filtered ("Selector $ss\n");
937 display_selector (current_thread
->h
,
938 current_thread
->context
.SegSs
);
939 puts_filtered ("Selector $fs\n");
940 display_selector (current_thread
->h
,
941 current_thread
->context
.SegFs
);
942 puts_filtered ("Selector $gs\n");
943 display_selector (current_thread
->h
,
944 current_thread
->context
.SegGs
);
949 sel
= parse_and_eval_long (args
);
950 printf_filtered ("Selector \"%s\"\n",args
);
951 display_selector (current_thread
->h
, sel
);
955 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
958 info_w32_command (char *args
, int from_tty
)
960 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
964 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
965 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
966 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
969 handle_exception (struct target_waitstatus
*ourstatus
)
972 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
974 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
976 /* Record the context of the current thread */
977 th
= thread_rec (current_event
.dwThreadId
, -1);
981 case EXCEPTION_ACCESS_VIOLATION
:
982 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
983 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
985 case STATUS_STACK_OVERFLOW
:
986 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
987 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
989 case STATUS_FLOAT_DENORMAL_OPERAND
:
990 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
991 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
993 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
994 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
995 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
997 case STATUS_FLOAT_INEXACT_RESULT
:
998 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
999 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1001 case STATUS_FLOAT_INVALID_OPERATION
:
1002 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1003 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1005 case STATUS_FLOAT_OVERFLOW
:
1006 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1007 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1009 case STATUS_FLOAT_STACK_CHECK
:
1010 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1011 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1013 case STATUS_FLOAT_UNDERFLOW
:
1014 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1015 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1017 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1018 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1019 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1021 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1022 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1023 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1025 case STATUS_INTEGER_OVERFLOW
:
1026 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1027 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1029 case EXCEPTION_BREAKPOINT
:
1030 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1031 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1034 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1035 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1037 case DBG_CONTROL_BREAK
:
1038 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1039 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1041 case EXCEPTION_SINGLE_STEP
:
1042 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1043 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1045 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1046 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1047 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1049 case EXCEPTION_PRIV_INSTRUCTION
:
1050 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1051 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1053 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1054 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1055 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1058 if (current_event
.u
.Exception
.dwFirstChance
)
1060 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1061 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1062 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1063 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1067 last_sig
= ourstatus
->value
.sig
;
1071 /* Resume all artificially suspended threads if we are continuing
1074 child_continue (DWORD continue_status
, int id
)
1080 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1081 current_event
.dwProcessId
, current_event
.dwThreadId
,
1082 continue_status
== DBG_CONTINUE
?
1083 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1084 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1085 current_event
.dwThreadId
,
1087 continue_status
= 0;
1089 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1090 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1093 for (i
= 0; i
< th
->suspend_count
; i
++)
1094 (void) ResumeThread (th
->h
);
1095 th
->suspend_count
= 0;
1096 if (debug_registers_changed
)
1098 /* Only change the value of the debug reisters */
1099 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1100 th
->context
.Dr0
= dr
[0];
1101 th
->context
.Dr1
= dr
[1];
1102 th
->context
.Dr2
= dr
[2];
1103 th
->context
.Dr3
= dr
[3];
1104 /* th->context.Dr6 = dr[6];
1105 FIXME: should we set dr6 also ?? */
1106 th
->context
.Dr7
= dr
[7];
1107 CHECK (SetThreadContext (th
->h
, &th
->context
));
1108 th
->context
.ContextFlags
= 0;
1112 debug_registers_changed
= 0;
1116 /* Get the next event from the child. Return 1 if the event requires
1117 handling by WFI (or whatever).
1120 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1123 DWORD continue_status
, event_code
;
1124 thread_info
*th
= NULL
;
1125 static thread_info dummy_thread_info
;
1128 last_sig
= TARGET_SIGNAL_0
;
1130 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1134 continue_status
= DBG_CONTINUE
;
1136 event_code
= current_event
.dwDebugEventCode
;
1137 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1141 case CREATE_THREAD_DEBUG_EVENT
:
1142 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1143 (unsigned) current_event
.dwProcessId
,
1144 (unsigned) current_event
.dwThreadId
,
1145 "CREATE_THREAD_DEBUG_EVENT"));
1146 if (saw_create
!= 1)
1148 /* Record the existence of this thread */
1149 th
= child_add_thread (current_event
.dwThreadId
,
1150 current_event
.u
.CreateThread
.hThread
);
1152 printf_unfiltered ("[New %s]\n",
1154 pid_to_ptid (current_event
.dwThreadId
)));
1155 retval
= current_event
.dwThreadId
;
1158 case EXIT_THREAD_DEBUG_EVENT
:
1159 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1160 (unsigned) current_event
.dwProcessId
,
1161 (unsigned) current_event
.dwThreadId
,
1162 "EXIT_THREAD_DEBUG_EVENT"));
1163 if (saw_create
!= 1)
1165 child_delete_thread (current_event
.dwThreadId
);
1166 th
= &dummy_thread_info
;
1169 case CREATE_PROCESS_DEBUG_EVENT
:
1170 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1171 (unsigned) current_event
.dwProcessId
,
1172 (unsigned) current_event
.dwThreadId
,
1173 "CREATE_PROCESS_DEBUG_EVENT"));
1174 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1175 if (++saw_create
!= 1)
1177 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1181 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1182 main_thread_id
= current_event
.dwThreadId
;
1183 /* Add the main thread */
1185 th
= child_add_thread (current_event
.dwProcessId
,
1186 current_event
.u
.CreateProcessInfo
.hProcess
);
1188 th
= child_add_thread (main_thread_id
,
1189 current_event
.u
.CreateProcessInfo
.hThread
);
1190 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1193 case EXIT_PROCESS_DEBUG_EVENT
:
1194 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1195 (unsigned) current_event
.dwProcessId
,
1196 (unsigned) current_event
.dwThreadId
,
1197 "EXIT_PROCESS_DEBUG_EVENT"));
1198 if (saw_create
!= 1)
1200 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1201 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1202 CloseHandle (current_process_handle
);
1203 retval
= main_thread_id
;
1206 case LOAD_DLL_DEBUG_EVENT
:
1207 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1208 (unsigned) current_event
.dwProcessId
,
1209 (unsigned) current_event
.dwThreadId
,
1210 "LOAD_DLL_DEBUG_EVENT"));
1211 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1212 if (saw_create
!= 1)
1214 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1215 registers_changed (); /* mark all regs invalid */
1216 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1217 ourstatus
->value
.integer
= 0;
1218 retval
= main_thread_id
;
1219 re_enable_breakpoints_in_shlibs ();
1222 case UNLOAD_DLL_DEBUG_EVENT
:
1223 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1224 (unsigned) current_event
.dwProcessId
,
1225 (unsigned) current_event
.dwThreadId
,
1226 "UNLOAD_DLL_DEBUG_EVENT"));
1227 if (saw_create
!= 1)
1229 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1230 registers_changed (); /* mark all regs invalid */
1231 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1232 does not exist yet. */
1235 case EXCEPTION_DEBUG_EVENT
:
1236 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1237 (unsigned) current_event
.dwProcessId
,
1238 (unsigned) current_event
.dwThreadId
,
1239 "EXCEPTION_DEBUG_EVENT"));
1240 if (saw_create
!= 1)
1242 if (handle_exception (ourstatus
))
1243 retval
= current_event
.dwThreadId
;
1246 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1247 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1248 (unsigned) current_event
.dwProcessId
,
1249 (unsigned) current_event
.dwThreadId
,
1250 "OUTPUT_DEBUG_STRING_EVENT"));
1251 if (saw_create
!= 1)
1253 if (handle_output_debug_string (ourstatus
))
1254 retval
= main_thread_id
;
1258 if (saw_create
!= 1)
1260 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1261 (DWORD
) current_event
.dwProcessId
,
1262 (DWORD
) current_event
.dwThreadId
);
1263 printf_unfiltered (" unknown event code %ld\n",
1264 current_event
.dwDebugEventCode
);
1268 if (!retval
|| saw_create
!= 1)
1269 CHECK (child_continue (continue_status
, -1));
1272 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1273 inferior_ptid
= pid_to_ptid (retval
);
1280 /* Wait for interesting events to occur in the target process. */
1282 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1284 int pid
= PIDGET (ptid
);
1286 /* We loop when we get a non-standard exception rather than return
1287 with a SPURIOUS because resume can try and step or modify things,
1288 which needs a current_thread->h. But some of these exceptions mark
1289 the birth or death of threads, which mean that the current thread
1290 isn't necessarily what you think it is. */
1294 int retval
= get_child_debug_event (pid
, ourstatus
);
1296 return pid_to_ptid (retval
);
1301 if (ui_loop_hook
!= NULL
)
1302 detach
= ui_loop_hook (0);
1305 child_kill_inferior ();
1311 do_initial_child_stuff (DWORD pid
)
1313 extern int stop_after_trap
;
1316 last_sig
= TARGET_SIGNAL_0
;
1318 exception_count
= 0;
1319 debug_registers_changed
= 0;
1320 debug_registers_used
= 0;
1321 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1323 current_event
.dwProcessId
= pid
;
1324 memset (¤t_event
, 0, sizeof (current_event
));
1325 push_target (&child_ops
);
1326 child_init_thread_list ();
1327 disable_breakpoints_in_shlibs (1);
1328 child_clear_solibs ();
1329 clear_proceed_status ();
1330 init_wait_for_inferior ();
1332 target_terminal_init ();
1333 target_terminal_inferior ();
1337 stop_after_trap
= 1;
1338 wait_for_inferior ();
1339 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1340 resume (0, stop_signal
);
1344 stop_after_trap
= 0;
1348 /* Since Windows XP, detaching from a process is supported by Windows.
1349 The following code tries loading the appropriate functions dynamically.
1350 If loading these functions succeeds use them to actually detach from
1351 the inferior process, otherwise behave as usual, pretending that
1352 detach has worked. */
1353 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1354 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1357 has_detach_ability (void)
1359 static HMODULE kernel32
= NULL
;
1362 kernel32
= LoadLibrary ("kernel32.dll");
1365 if (!DebugSetProcessKillOnExit
)
1366 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1367 "DebugSetProcessKillOnExit");
1368 if (!DebugActiveProcessStop
)
1369 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1370 "DebugActiveProcessStop");
1371 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1377 /* Attach to process PID, then initialize for debugging it. */
1379 child_attach (char *args
, int from_tty
)
1385 error_no_arg ("process-id to attach");
1387 pid
= strtoul (args
, 0, 0);
1388 ok
= DebugActiveProcess (pid
);
1391 error ("Can't attach to process.");
1393 if (has_detach_ability ())
1396 DebugSetProcessKillOnExit (FALSE
);
1401 char *exec_file
= (char *) get_exec_file (0);
1404 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1405 target_pid_to_str (pid_to_ptid (pid
)));
1407 printf_unfiltered ("Attaching to %s\n",
1408 target_pid_to_str (pid_to_ptid (pid
)));
1410 gdb_flush (gdb_stdout
);
1413 do_initial_child_stuff (pid
);
1414 target_terminal_ours ();
1418 child_detach (char *args
, int from_tty
)
1422 if (has_detach_ability ())
1424 delete_command (NULL
, 0);
1425 child_continue (DBG_CONTINUE
, -1);
1426 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1428 error ("Can't detach process %lu (error %lu)",
1429 current_event
.dwProcessId
, GetLastError ());
1432 DebugSetProcessKillOnExit (FALSE
);
1434 if (detached
&& from_tty
)
1436 char *exec_file
= get_exec_file (0);
1439 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1440 current_event
.dwProcessId
);
1441 gdb_flush (gdb_stdout
);
1443 inferior_ptid
= null_ptid
;
1444 unpush_target (&child_ops
);
1447 /* Print status information about what we're accessing. */
1450 child_files_info (struct target_ops
*ignore
)
1452 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1453 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1458 child_open (char *arg
, int from_tty
)
1460 error ("Use the \"run\" command to start a Unix child process.");
1463 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1464 EXEC_FILE is the file to run.
1465 ALLARGS is a string containing the arguments to the program.
1466 ENV is the environment vector to pass. Errors reported with error(). */
1469 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1476 PROCESS_INFORMATION pi
;
1480 char real_path
[MAXPATHLEN
];
1482 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1485 int ostdin
, ostdout
, ostderr
;
1488 error ("No executable specified, use `target exec'.\n");
1490 memset (&si
, 0, sizeof (si
));
1491 si
.cb
= sizeof (si
);
1495 flags
= DEBUG_ONLY_THIS_PROCESS
;
1496 cygwin_conv_to_win32_path (exec_file
, real_path
);
1502 sh
= getenv ("SHELL");
1505 cygwin_conv_to_win32_path (sh
, shell
);
1506 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1507 + strlen (allargs
) + 2);
1508 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1509 allargs
= newallargs
;
1511 flags
= DEBUG_PROCESS
;
1515 flags
|= CREATE_NEW_PROCESS_GROUP
;
1518 flags
|= CREATE_NEW_CONSOLE
;
1520 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1521 strcpy (args
, toexec
);
1523 strcat (args
, allargs
);
1525 /* Prepare the environment vars for CreateProcess. */
1527 /* This code used to assume all env vars were file names and would
1528 translate them all to win32 style. That obviously doesn't work in the
1529 general case. The current rule is that we only translate PATH.
1530 We need to handle PATH because we're about to call CreateProcess and
1531 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1532 in both posix and win32 environments. cygwin.dll will change it back
1533 to posix style if necessary. */
1535 static const char *conv_path_names
[] =
1541 /* CreateProcess takes the environment list as a null terminated set of
1542 strings (i.e. two nulls terminate the list). */
1544 /* Get total size for env strings. */
1545 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1549 for (j
= 0; conv_path_names
[j
]; j
++)
1551 len
= strlen (conv_path_names
[j
]);
1552 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1554 if (cygwin_posix_path_list_p (env
[i
] + len
))
1556 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1558 envlen
+= strlen (env
[i
]) + 1;
1562 if (conv_path_names
[j
] == NULL
)
1563 envlen
+= strlen (env
[i
]) + 1;
1566 winenv
= alloca (envlen
+ 1);
1568 /* Copy env strings into new buffer. */
1569 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1573 for (j
= 0; conv_path_names
[j
]; j
++)
1575 len
= strlen (conv_path_names
[j
]);
1576 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1578 if (cygwin_posix_path_list_p (env
[i
] + len
))
1580 memcpy (temp
, env
[i
], len
);
1581 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1584 strcpy (temp
, env
[i
]);
1588 if (conv_path_names
[j
] == NULL
)
1589 strcpy (temp
, env
[i
]);
1591 temp
+= strlen (temp
) + 1;
1594 /* Final nil string to terminate new env. */
1598 if (!inferior_io_terminal
)
1599 tty
= ostdin
= ostdout
= ostderr
= -1;
1602 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1605 print_sys_errmsg (inferior_io_terminal
, errno
);
1606 ostdin
= ostdout
= ostderr
= -1;
1619 ret
= CreateProcess (0,
1620 args
, /* command line */
1621 NULL
, /* Security */
1623 TRUE
, /* inherit handles */
1624 flags
, /* start flags */
1626 NULL
, /* current directory */
1641 error ("Error creating process %s, (error %d)\n", exec_file
, (unsigned) GetLastError ());
1643 CloseHandle (pi
.hThread
);
1644 CloseHandle (pi
.hProcess
);
1646 if (useshell
&& shell
[0] != '\0')
1651 do_initial_child_stuff (pi
.dwProcessId
);
1653 /* child_continue (DBG_CONTINUE, -1); */
1654 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1658 child_mourn_inferior (void)
1660 (void) child_continue (DBG_CONTINUE
, -1);
1661 i386_cleanup_dregs();
1662 unpush_target (&child_ops
);
1663 generic_mourn_inferior ();
1666 /* Send a SIGINT to the process group. This acts just like the user typed a
1667 ^C on the controlling terminal. */
1672 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1673 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1674 registers_changed (); /* refresh register state */
1678 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1679 int write
, struct mem_attrib
*mem
,
1680 struct target_ops
*target
)
1685 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1686 len
, (DWORD
) memaddr
));
1687 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1689 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1693 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1694 len
, (DWORD
) memaddr
));
1695 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1702 child_kill_inferior (void)
1704 CHECK (TerminateProcess (current_process_handle
, 0));
1708 if (!child_continue (DBG_CONTINUE
, -1))
1710 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1712 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1716 CHECK (CloseHandle (current_process_handle
));
1718 /* this may fail in an attached process so don't check. */
1719 (void) CloseHandle (current_thread
->h
);
1720 target_mourn_inferior (); /* or just child_mourn_inferior? */
1724 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1727 DWORD continue_status
= DBG_CONTINUE
;
1729 int pid
= PIDGET (ptid
);
1731 if (sig
!= TARGET_SIGNAL_0
)
1733 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1735 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1737 else if (sig
== last_sig
)
1738 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1741 /* This code does not seem to work, because
1742 the kernel does probably not consider changes in the ExceptionRecord
1743 structure when passing the exception to the inferior.
1744 Note that this seems possible in the exception handler itself. */
1747 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1748 if (xlate
[i
].us
== sig
)
1750 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1752 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1755 if (continue_status
== DBG_CONTINUE
)
1757 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1761 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1765 last_sig
= TARGET_SIGNAL_0
;
1767 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1770 /* Get context for currently selected thread */
1771 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1776 /* Single step by setting t bit */
1777 child_fetch_inferior_registers (PS_REGNUM
);
1778 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1781 if (th
->context
.ContextFlags
)
1783 if (debug_registers_changed
)
1785 th
->context
.Dr0
= dr
[0];
1786 th
->context
.Dr1
= dr
[1];
1787 th
->context
.Dr2
= dr
[2];
1788 th
->context
.Dr3
= dr
[3];
1789 /* th->context.Dr6 = dr[6];
1790 FIXME: should we set dr6 also ?? */
1791 th
->context
.Dr7
= dr
[7];
1793 CHECK (SetThreadContext (th
->h
, &th
->context
));
1794 th
->context
.ContextFlags
= 0;
1798 /* Allow continuing with the same signal that interrupted us.
1799 Otherwise complain. */
1801 child_continue (continue_status
, pid
);
1805 child_prepare_to_store (void)
1807 /* Do nothing, since we can store individual regs */
1811 child_can_run (void)
1819 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1820 PIDGET (inferior_ptid
)));
1823 struct target_ops child_ops
;
1826 init_child_ops (void)
1828 child_ops
.to_shortname
= "child";
1829 child_ops
.to_longname
= "Win32 child process";
1830 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1831 child_ops
.to_open
= child_open
;
1832 child_ops
.to_close
= child_close
;
1833 child_ops
.to_attach
= child_attach
;
1834 child_ops
.to_detach
= child_detach
;
1835 child_ops
.to_resume
= child_resume
;
1836 child_ops
.to_wait
= child_wait
;
1837 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1838 child_ops
.to_store_registers
= child_store_inferior_registers
;
1839 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1840 child_ops
.to_xfer_memory
= child_xfer_memory
;
1841 child_ops
.to_files_info
= child_files_info
;
1842 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1843 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1844 child_ops
.to_terminal_init
= terminal_init_inferior
;
1845 child_ops
.to_terminal_inferior
= terminal_inferior
;
1846 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1847 child_ops
.to_terminal_ours
= terminal_ours
;
1848 child_ops
.to_terminal_save_ours
= terminal_save_ours
;
1849 child_ops
.to_terminal_info
= child_terminal_info
;
1850 child_ops
.to_kill
= child_kill_inferior
;
1851 child_ops
.to_create_inferior
= child_create_inferior
;
1852 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1853 child_ops
.to_can_run
= child_can_run
;
1854 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1855 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1856 child_ops
.to_stop
= child_stop
;
1857 child_ops
.to_stratum
= process_stratum
;
1858 child_ops
.to_has_all_memory
= 1;
1859 child_ops
.to_has_memory
= 1;
1860 child_ops
.to_has_stack
= 1;
1861 child_ops
.to_has_registers
= 1;
1862 child_ops
.to_has_execution
= 1;
1863 child_ops
.to_magic
= OPS_MAGIC
;
1867 _initialize_win32_nat (void)
1869 struct cmd_list_element
*c
;
1873 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1874 "Load dll library symbols from FILE.");
1875 set_cmd_completer (c
, filename_completer
);
1877 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1879 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
1881 "Set use of shell to start subprocess.",
1885 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1886 (char *) &new_console
,
1887 "Set creation of new console when creating child process.",
1891 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1892 (char *) &new_group
,
1893 "Set creation of new group when creating child process.",
1897 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1898 (char *) &debug_exec
,
1899 "Set whether to display execution in child process.",
1903 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1904 (char *) &debug_events
,
1905 "Set whether to display kernel events in child process.",
1909 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1910 (char *) &debug_memory
,
1911 "Set whether to display memory accesses in child process.",
1915 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1916 (char *) &debug_exceptions
,
1917 "Set whether to display kernel exceptions in child process.",
1921 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1922 add_info_alias ("sharedlibrary", "dll", 1);
1924 add_prefix_cmd ("w32", class_info
, info_w32_command
,
1925 "Print information specific to Win32 debugging.",
1926 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
1928 add_cmd ("selector", class_info
, display_selectors
,
1929 "Display selectors infos.",
1932 add_target (&child_ops
);
1935 /* Hardware watchpoint support, adapted from go32-nat.c code. */
1937 /* Pass the address ADDR to the inferior in the I'th debug register.
1938 Here we just store the address in dr array, the registers will be
1939 actually set up when child_continue is called. */
1941 cygwin_set_dr (int i
, CORE_ADDR addr
)
1944 internal_error (__FILE__
, __LINE__
,
1945 "Invalid register %d in cygwin_set_dr.\n", i
);
1946 dr
[i
] = (unsigned) addr
;
1947 debug_registers_changed
= 1;
1948 debug_registers_used
= 1;
1951 /* Pass the value VAL to the inferior in the DR7 debug control
1952 register. Here we just store the address in D_REGS, the watchpoint
1953 will be actually set up in child_wait. */
1955 cygwin_set_dr7 (unsigned val
)
1958 debug_registers_changed
= 1;
1959 debug_registers_used
= 1;
1962 /* Get the value of the DR6 debug status register from the inferior.
1963 Here we just return the value stored in dr[6]
1964 by the last call to thread_rec for current_event.dwThreadId id. */
1966 cygwin_get_dr6 (void)
1972 /* Determine if the thread referenced by "pid" is alive
1973 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1974 it means that the pid has died. Otherwise it is assumed to be alive. */
1976 win32_child_thread_alive (ptid_t ptid
)
1978 int pid
= PIDGET (ptid
);
1980 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1984 /* Convert pid to printable format. */
1986 cygwin_pid_to_str (ptid_t ptid
)
1988 static char buf
[80];
1989 int pid
= PIDGET (ptid
);
1991 if ((DWORD
) pid
== current_event
.dwProcessId
)
1992 sprintf (buf
, "process %d", pid
);
1994 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1999 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
2001 struct objfile
*objfile
;
2002 char *objfile_basename
;
2003 const char *dll_basename
;
2005 if (!(dll_basename
= strrchr (dll_name
, '/')))
2006 dll_basename
= dll_name
;
2010 ALL_OBJFILES (objfile
)
2012 objfile_basename
= strrchr (objfile
->name
, '/');
2014 if (objfile_basename
&&
2015 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
2017 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2018 base_addr
, dll_name
);
2023 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
2024 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
2032 struct target_ops
*target
;
2035 map_code_section_args
;
2038 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2042 struct section_table
*new_target_sect_ptr
;
2044 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2045 struct target_ops
*target
= args
->target
;
2046 if (sect
->flags
& SEC_CODE
)
2048 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2050 if (target
->to_sections
)
2052 old
= target
->to_sections_end
- target
->to_sections
;
2053 target
->to_sections
= (struct section_table
*)
2054 xrealloc ((char *) target
->to_sections
,
2055 (sizeof (struct section_table
)) * (1 + old
));
2060 target
->to_sections
= (struct section_table
*)
2061 xmalloc ((sizeof (struct section_table
)));
2063 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2065 /* Update the to_sections field in the core_ops structure
2069 core_ops
.to_sections
= target
->to_sections
;
2070 core_ops
.to_sections_end
= target
->to_sections_end
;
2072 new_target_sect_ptr
= target
->to_sections
+ old
;
2073 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2074 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2075 bfd_section_size (abfd
, sect
);;
2076 new_target_sect_ptr
->the_bfd_section
= sect
;
2077 new_target_sect_ptr
->bfd
= abfd
;
2082 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2085 map_code_section_args map_args
;
2086 asection
*lowest_sect
;
2088 if (dll_name
== NULL
|| target
== NULL
)
2090 name
= xstrdup (dll_name
);
2091 dll_bfd
= bfd_openr (name
, "pei-i386");
2092 if (dll_bfd
== NULL
)
2095 if (bfd_check_format (dll_bfd
, bfd_object
))
2097 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2098 if (lowest_sect
== NULL
)
2100 map_args
.target
= target
;
2101 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2103 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2110 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2112 struct target_ops
*target
= (struct target_ops
*) obj
;
2117 char *dll_name
= NULL
;
2119 struct win32_pstatus
*pstatus
;
2122 if (strncmp (sect
->name
, ".module", 7))
2125 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2128 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2131 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2134 pstatus
= (struct win32_pstatus
*) buf
;
2136 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2137 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2138 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2141 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2144 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2147 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2149 while ((p
= strchr (dll_name
, '\\')))
2152 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2153 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2155 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2156 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2167 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2174 child_clear_solibs ();
2175 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2179 if (solib_end
&& solib_end
->name
)
2180 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2181 solib_end
->load_addr
);
2186 fetch_elf_core_registers (char *core_reg_sect
,
2187 unsigned core_reg_size
,
2192 if (core_reg_size
< sizeof (CONTEXT
))
2194 error ("Core file register section too small (%u bytes).", core_reg_size
);
2197 for (r
= 0; r
< NUM_REGS
; r
++)
2198 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2201 static struct core_fns win32_elf_core_fns
=
2203 bfd_target_elf_flavour
,
2204 default_check_format
,
2205 default_core_sniffer
,
2206 fetch_elf_core_registers
,
2211 _initialize_core_win32 (void)
2213 add_core_fns (&win32_elf_core_fns
);
2217 _initialize_check_for_gdb_ini (void)
2220 if (inhibit_gdbinit
)
2223 homedir
= getenv ("HOME");
2227 char *oldini
= (char *) alloca (strlen (homedir
) +
2228 sizeof ("/gdb.ini"));
2229 strcpy (oldini
, homedir
);
2230 p
= strchr (oldini
, '\0');
2231 if (p
> oldini
&& p
[-1] != '/')
2233 strcpy (p
, "gdb.ini");
2234 if (access (oldini
, 0) == 0)
2236 int len
= strlen (oldini
);
2237 char *newini
= alloca (len
+ 1);
2238 sprintf (newini
, "%.*s.gdbinit",
2239 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2240 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);