1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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 "frame.h" /* required by inferior.h */
35 #include "completer.h"
38 #include "i386-tdep.h"
40 #include <sys/types.h>
45 #include <sys/cygwin.h>
50 #include "gdb_string.h"
51 #include "gdbthread.h"
53 #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>
73 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
74 | CONTEXT_EXTENDED_REGISTERS
76 static unsigned dr
[8];
77 static int debug_registers_changed
= 0;
78 static int debug_registers_used
= 0;
80 /* The string sent by cygwin when it processes a signal.
81 FIXME: This should be in a cygwin include file. */
82 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
84 #define CHECK(x) check (x, __FILE__,__LINE__)
85 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
86 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
87 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
88 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
90 /* Forward declaration */
91 extern struct target_ops child_ops
;
93 static void child_stop (void);
94 static int win32_child_thread_alive (ptid_t
);
95 void child_kill_inferior (void);
97 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
98 /* Set if a signal was received from the debugged process */
100 /* Thread information structure used to track information that is
101 not available in gdb's thread structure. */
102 typedef struct thread_info_struct
104 struct thread_info_struct
*next
;
114 static thread_info thread_head
;
116 /* The process and thread handles for the above context. */
118 static DEBUG_EVENT current_event
; /* The current debug event from
120 static HANDLE current_process_handle
; /* Currently executing process */
121 static thread_info
*current_thread
; /* Info on currently selected thread */
122 static DWORD main_thread_id
; /* Thread ID of the main thread */
124 /* Counts of things. */
125 static int exception_count
= 0;
126 static int event_count
= 0;
127 static int saw_create
;
130 static int new_console
= 0;
131 static int new_group
= 1;
132 static int debug_exec
= 0; /* show execution */
133 static int debug_events
= 0; /* show events from kernel */
134 static int debug_memory
= 0; /* show target memory accesses */
135 static int debug_exceptions
= 0; /* show target exceptions */
136 static int useshell
= 0; /* use shell for subprocesses */
138 /* This vector maps GDB's idea of a register's number into an address
139 in the win32 exception context vector.
141 It also contains the bit mask needed to load the register in question.
143 One day we could read a reg, we could inspect the context we
144 already have loaded, if it doesn't have the bit set that we need,
145 we read that set of registers in using GetThreadContext. If the
146 context already contains what we need, we just unpack it. Then to
147 write a register, first we have to ensure that the context contains
148 the other regs of the group, and then we copy the info in and set
151 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
152 static const int mappings
[] =
154 context_offset (Eax
),
155 context_offset (Ecx
),
156 context_offset (Edx
),
157 context_offset (Ebx
),
158 context_offset (Esp
),
159 context_offset (Ebp
),
160 context_offset (Esi
),
161 context_offset (Edi
),
162 context_offset (Eip
),
163 context_offset (EFlags
),
164 context_offset (SegCs
),
165 context_offset (SegSs
),
166 context_offset (SegDs
),
167 context_offset (SegEs
),
168 context_offset (SegFs
),
169 context_offset (SegGs
),
170 context_offset (FloatSave
.RegisterArea
[0 * 10]),
171 context_offset (FloatSave
.RegisterArea
[1 * 10]),
172 context_offset (FloatSave
.RegisterArea
[2 * 10]),
173 context_offset (FloatSave
.RegisterArea
[3 * 10]),
174 context_offset (FloatSave
.RegisterArea
[4 * 10]),
175 context_offset (FloatSave
.RegisterArea
[5 * 10]),
176 context_offset (FloatSave
.RegisterArea
[6 * 10]),
177 context_offset (FloatSave
.RegisterArea
[7 * 10]),
178 context_offset (FloatSave
.ControlWord
),
179 context_offset (FloatSave
.StatusWord
),
180 context_offset (FloatSave
.TagWord
),
181 context_offset (FloatSave
.ErrorSelector
),
182 context_offset (FloatSave
.ErrorOffset
),
183 context_offset (FloatSave
.DataSelector
),
184 context_offset (FloatSave
.DataOffset
),
185 context_offset (FloatSave
.ErrorSelector
)
187 context_offset (ExtendedRegisters
[10*16]),
188 context_offset (ExtendedRegisters
[11*16]),
189 context_offset (ExtendedRegisters
[12*16]),
190 context_offset (ExtendedRegisters
[13*16]),
191 context_offset (ExtendedRegisters
[14*16]),
192 context_offset (ExtendedRegisters
[15*16]),
193 context_offset (ExtendedRegisters
[16*16]),
194 context_offset (ExtendedRegisters
[17*16]),
196 context_offset (ExtendedRegisters
[24])
199 #undef context_offset
201 /* This vector maps the target's idea of an exception (extracted
202 from the DEBUG_EVENT structure) to GDB's idea. */
204 struct xlate_exception
207 enum target_signal us
;
210 static const struct xlate_exception
213 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
214 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
215 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
216 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
217 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
218 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
222 check (BOOL ok
, const char *file
, int line
)
225 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
230 /* Find a thread record given a thread id.
231 If get_context then also retrieve the context for this
234 thread_rec (DWORD id
, int get_context
)
238 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
241 if (!th
->suspend_count
&& get_context
)
243 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
244 th
->suspend_count
= SuspendThread (th
->h
) + 1;
245 else if (get_context
< 0)
246 th
->suspend_count
= -1;
248 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
249 GetThreadContext (th
->h
, &th
->context
);
250 if (id
== current_event
.dwThreadId
)
252 /* Copy dr values from that thread. */
253 dr
[0] = th
->context
.Dr0
;
254 dr
[1] = th
->context
.Dr1
;
255 dr
[2] = th
->context
.Dr2
;
256 dr
[3] = th
->context
.Dr3
;
257 dr
[6] = th
->context
.Dr6
;
258 dr
[7] = th
->context
.Dr7
;
267 /* Add a thread to the thread list */
269 child_add_thread (DWORD id
, HANDLE h
)
273 if ((th
= thread_rec (id
, FALSE
)))
276 th
= (thread_info
*) xmalloc (sizeof (*th
));
277 memset (th
, 0, sizeof (*th
));
280 th
->next
= thread_head
.next
;
281 thread_head
.next
= th
;
282 add_thread (pid_to_ptid (id
));
283 /* Set the debug registers for the new thread in they are used. */
284 if (debug_registers_used
)
286 /* Only change the value of the debug registers. */
287 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
288 CHECK (GetThreadContext (th
->h
, &th
->context
));
289 th
->context
.Dr0
= dr
[0];
290 th
->context
.Dr1
= dr
[1];
291 th
->context
.Dr2
= dr
[2];
292 th
->context
.Dr3
= dr
[3];
293 /* th->context.Dr6 = dr[6];
294 FIXME: should we set dr6 also ?? */
295 th
->context
.Dr7
= dr
[7];
296 CHECK (SetThreadContext (th
->h
, &th
->context
));
297 th
->context
.ContextFlags
= 0;
302 /* Clear out any old thread list and reintialize it to a
305 child_init_thread_list (void)
307 thread_info
*th
= &thread_head
;
309 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
311 while (th
->next
!= NULL
)
313 thread_info
*here
= th
->next
;
314 th
->next
= here
->next
;
315 (void) CloseHandle (here
->h
);
320 /* Delete a thread from the list of threads */
322 child_delete_thread (DWORD id
)
327 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
328 delete_thread (pid_to_ptid (id
));
330 for (th
= &thread_head
;
331 th
->next
!= NULL
&& th
->next
->id
!= id
;
335 if (th
->next
!= NULL
)
337 thread_info
*here
= th
->next
;
338 th
->next
= here
->next
;
339 CloseHandle (here
->h
);
345 do_child_fetch_inferior_registers (int r
)
347 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
351 l
= *((long *) context_offset
) & 0xffff;
352 supply_register (r
, (char *) &l
);
354 else if (r
== FOP_REGNUM
)
356 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
357 supply_register (r
, (char *) &l
);
360 supply_register (r
, context_offset
);
363 for (r
= 0; r
< NUM_REGS
; r
++)
364 do_child_fetch_inferior_registers (r
);
369 child_fetch_inferior_registers (int r
)
371 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
372 do_child_fetch_inferior_registers (r
);
376 do_child_store_inferior_registers (int r
)
379 regcache_collect (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
382 for (r
= 0; r
< NUM_REGS
; r
++)
383 do_child_store_inferior_registers (r
);
387 /* Store a new register value into the current thread context */
389 child_store_inferior_registers (int r
)
391 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
392 do_child_store_inferior_registers (r
);
395 static int psapi_loaded
= 0;
396 static HMODULE psapi_module_handle
= NULL
;
397 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
398 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
399 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
402 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
408 HMODULE
*DllHandle
= dh_buf
;
413 psapi_EnumProcessModules
== NULL
||
414 psapi_GetModuleInformation
== NULL
||
415 psapi_GetModuleFileNameExA
== NULL
)
420 psapi_module_handle
= LoadLibrary ("psapi.dll");
421 if (!psapi_module_handle
)
423 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
426 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
427 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
428 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
429 "GetModuleFileNameExA");
430 if (psapi_EnumProcessModules
== NULL
||
431 psapi_GetModuleInformation
== NULL
||
432 psapi_GetModuleFileNameExA
== NULL
)
437 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
442 if (!ok
|| !cbNeeded
)
445 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
449 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
456 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
458 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
462 error ("Can't get module info");
464 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
469 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
471 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
476 dll_name_ret
[0] = '\0';
480 /* Encapsulate the information required in a call to
481 symbol_file_add_args */
482 struct safe_symbol_file_add_args
486 struct section_addr_info
*addrs
;
489 struct ui_file
*err
, *out
;
493 /* Maintain a linked list of "so" information. */
496 struct so_stuff
*next
;
500 struct objfile
*objfile
;
502 } solib_start
, *solib_end
;
504 /* Call symbol_file_add with stderr redirected. We don't care if there
507 safe_symbol_file_add_stub (void *argv
)
509 #define p ((struct safe_symbol_file_add_args *)argv)
510 struct so_stuff
*so
= &solib_start
;
512 while ((so
= so
->next
))
513 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
515 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
520 /* Restore gdb's stderr after calling symbol_file_add */
522 safe_symbol_file_add_cleanup (void *p
)
524 #define sp ((struct safe_symbol_file_add_args *)p)
525 gdb_flush (gdb_stderr
);
526 gdb_flush (gdb_stdout
);
527 ui_file_delete (gdb_stderr
);
528 ui_file_delete (gdb_stdout
);
529 gdb_stderr
= sp
->err
;
530 gdb_stdout
= sp
->out
;
534 /* symbol_file_add wrapper that prevents errors from being displayed. */
535 static struct objfile
*
536 safe_symbol_file_add (char *name
, int from_tty
,
537 struct section_addr_info
*addrs
,
538 int mainline
, int flags
)
540 struct safe_symbol_file_add_args p
;
541 struct cleanup
*cleanup
;
543 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
547 gdb_flush (gdb_stderr
);
548 gdb_flush (gdb_stdout
);
549 gdb_stderr
= ui_file_new ();
550 gdb_stdout
= ui_file_new ();
552 p
.from_tty
= from_tty
;
554 p
.mainline
= mainline
;
556 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
558 do_cleanups (cleanup
);
562 /* Remember the maximum DLL length for printing in info dll command. */
563 int max_dll_name_len
;
566 register_loaded_dll (const char *name
, DWORD load_addr
)
569 char ppath
[MAX_PATH
+ 1];
570 char buf
[MAX_PATH
+ 1];
571 char cwd
[MAX_PATH
+ 1];
573 WIN32_FIND_DATA w32_fd
;
574 HANDLE h
= FindFirstFile(name
, &w32_fd
);
575 MEMORY_BASIC_INFORMATION m
;
578 if (h
== INVALID_HANDLE_VALUE
)
584 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
586 p
= strrchr (buf
, '\\');
589 SetCurrentDirectory (buf
);
590 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
591 SetCurrentDirectory (cwd
);
595 cygwin_conv_to_posix_path (buf
, ppath
);
596 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
598 so
->load_addr
= load_addr
;
599 if (VirtualQueryEx (current_process_handle
, (void *) load_addr
, &m
,
601 so
->end_addr
= (DWORD
) m
.AllocationBase
+ m
.RegionSize
;
603 so
->end_addr
= load_addr
+ 0x2000; /* completely arbitrary */
607 strcpy (so
->name
, ppath
);
609 solib_end
->next
= so
;
611 len
= strlen (ppath
);
612 if (len
> max_dll_name_len
)
613 max_dll_name_len
= len
;
617 get_image_name (HANDLE h
, void *address
, int unicode
)
619 static char buf
[(2 * MAX_PATH
) + 1];
620 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
626 /* Attempt to read the name of the dll that was detected.
627 This is documented to work only when actively debugging
628 a program. It will not work for attached processes. */
632 /* See if we could read the address of a string, and that the
633 address isn't null. */
634 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
635 || done
!= sizeof (address_ptr
) || !address_ptr
)
638 /* Find the length of the string */
639 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
640 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
644 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
647 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
648 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
651 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
657 /* Wait for child to do something. Return pid of child, or -1 in case
658 of error; store status through argument pointer OURSTATUS. */
660 handle_load_dll (void *dummy
)
662 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
663 char dll_buf
[MAX_PATH
+ 1];
664 char *dll_name
= NULL
;
667 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
669 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
670 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
674 if (*dll_name
== '\0')
675 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
679 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
685 handle_unload_dll (void *dummy
)
687 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
690 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
691 if (so
->next
->load_addr
== lpBaseOfDll
)
693 struct so_stuff
*sodel
= so
->next
;
694 so
->next
= sodel
->next
;
698 free_objfile (sodel
->objfile
);
702 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
708 solib_address (CORE_ADDR address
)
711 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
712 if (address
>= so
->load_addr
&& address
<= so
->end_addr
)
717 /* Return name of last loaded DLL. */
719 child_solib_loaded_library_pathname (int pid
)
721 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
724 /* Clear list of loaded DLLs. */
726 child_clear_solibs (void)
728 struct so_stuff
*so
, *so1
= solib_start
.next
;
730 while ((so
= so1
) != NULL
)
736 solib_start
.next
= NULL
;
737 solib_start
.objfile
= NULL
;
738 solib_end
= &solib_start
;
739 max_dll_name_len
= sizeof ("DLL Name") - 1;
742 /* Get the loaded address of all sections, given that .text was loaded
743 at text_load. Assumes that all sections are subject to the same
744 relocation offset. Returns NULL if problems occur or if the
745 sections were not relocated. */
747 static struct section_addr_info
*
748 get_relocated_section_addrs (bfd
*abfd
, CORE_ADDR text_load
)
750 struct section_addr_info
*result
= NULL
;
751 int section_count
= bfd_count_sections (abfd
);
752 asection
*text_section
= bfd_get_section_by_name (abfd
, ".text");
757 /* Couldn't get the .text section. Weird. */
760 else if (text_load
== (text_vma
= bfd_get_section_vma (abfd
, text_section
)))
762 /* DLL wasn't relocated. */
767 /* Figure out all sections' loaded addresses. The offset here is
768 such that taking a bfd_get_section_vma() result and adding
769 offset will give the real load address of the section. */
771 CORE_ADDR offset
= text_load
- text_vma
;
773 struct section_table
*table_start
= NULL
;
774 struct section_table
*table_end
= NULL
;
775 struct section_table
*iter
= NULL
;
777 build_section_table (abfd
, &table_start
, &table_end
);
779 for (iter
= table_start
; iter
< table_end
; ++iter
)
781 /* Relocated addresses. */
782 iter
->addr
+= offset
;
783 iter
->endaddr
+= offset
;
786 result
= build_section_addr_info_from_section_table (table_start
,
795 /* Add DLL symbol information. */
796 static struct objfile
*
797 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
799 struct section_addr_info
*addrs
= NULL
;
800 static struct objfile
*result
= NULL
;
803 /* The symbols in a dll are offset by 0x1000, which is the
804 the offset from 0 of the first byte in an image - because
805 of the file header and the section alignment. */
807 if (!name
|| !name
[0])
810 abfd
= bfd_openr (name
, "pei-i386");
814 /* pei failed - try pe */
815 abfd
= bfd_openr (name
, "pe-i386");
820 if (bfd_check_format (abfd
, bfd_object
))
822 addrs
= get_relocated_section_addrs (abfd
, load_addr
);
830 result
= safe_symbol_file_add (name
, from_tty
, addrs
, 0, OBJF_SHARED
);
831 free_section_addr_info (addrs
);
835 /* Fallback on handling just the .text section. */
836 struct cleanup
*my_cleanups
;
838 addrs
= alloc_section_addr_info (1);
839 my_cleanups
= make_cleanup (xfree
, addrs
);
840 addrs
->other
[0].name
= ".text";
841 addrs
->other
[0].addr
= load_addr
;
843 result
= safe_symbol_file_add (name
, from_tty
, addrs
, 0, OBJF_SHARED
);
844 do_cleanups (my_cleanups
);
850 /* Load DLL symbol info. */
852 dll_symbol_command (char *args
, int from_tty
)
858 error ("dll-symbols requires a file name");
861 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
863 char *newargs
= (char *) alloca (n
+ 4 + 1);
864 strcpy (newargs
, args
);
865 strcat (newargs
, ".dll");
869 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
872 /* List currently loaded DLLs. */
874 info_dll_command (char *ignore
, int from_tty
)
876 struct so_stuff
*so
= &solib_start
;
881 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
882 while ((so
= so
->next
) != NULL
)
883 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
888 /* Handle DEBUG_STRING output from child process.
889 Cygwin prepends its messages with a "cygwin:". Interpret this as
890 a Cygwin signal. Otherwise just print the string as a warning. */
892 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
897 if (!target_read_string
898 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
902 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
904 if (strncmp (s
, "cYg", 3) != 0)
910 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
911 gotasig
= target_signal_from_host (sig
);
912 ourstatus
->value
.sig
= gotasig
;
914 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
922 display_selector (HANDLE thread
, DWORD sel
)
925 if (GetThreadSelectorEntry (thread
, sel
, &info
))
928 printf_filtered ("0x%03lx: ", sel
);
929 if (!info
.HighWord
.Bits
.Pres
)
931 puts_filtered ("Segment not present\n");
934 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
935 (info
.HighWord
.Bits
.BaseMid
<< 16)
937 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
938 if (info
.HighWord
.Bits
.Granularity
)
939 limit
= (limit
<< 12) | 0xfff;
940 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
941 if (info
.HighWord
.Bits
.Default_Big
)
942 puts_filtered(" 32-bit ");
944 puts_filtered(" 16-bit ");
945 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
948 puts_filtered ("Data (Read-Only, Exp-up");
951 puts_filtered ("Data (Read/Write, Exp-up");
954 puts_filtered ("Unused segment (");
957 puts_filtered ("Data (Read/Write, Exp-down");
960 puts_filtered ("Code (Exec-Only, N.Conf");
963 puts_filtered ("Code (Exec/Read, N.Conf");
966 puts_filtered ("Code (Exec-Only, Conf");
969 puts_filtered ("Code (Exec/Read, Conf");
972 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
974 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
975 puts_filtered(", N.Acc");
976 puts_filtered (")\n");
977 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
978 puts_filtered("System selector ");
979 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
980 if (info
.HighWord
.Bits
.Granularity
)
981 puts_filtered ("Page granular.\n");
983 puts_filtered ("Byte granular.\n");
988 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
994 display_selectors (char * args
, int from_tty
)
998 puts_filtered ("Impossible to display selectors now.\n");
1004 puts_filtered ("Selector $cs\n");
1005 display_selector (current_thread
->h
,
1006 current_thread
->context
.SegCs
);
1007 puts_filtered ("Selector $ds\n");
1008 display_selector (current_thread
->h
,
1009 current_thread
->context
.SegDs
);
1010 puts_filtered ("Selector $es\n");
1011 display_selector (current_thread
->h
,
1012 current_thread
->context
.SegEs
);
1013 puts_filtered ("Selector $ss\n");
1014 display_selector (current_thread
->h
,
1015 current_thread
->context
.SegSs
);
1016 puts_filtered ("Selector $fs\n");
1017 display_selector (current_thread
->h
,
1018 current_thread
->context
.SegFs
);
1019 puts_filtered ("Selector $gs\n");
1020 display_selector (current_thread
->h
,
1021 current_thread
->context
.SegGs
);
1026 sel
= parse_and_eval_long (args
);
1027 printf_filtered ("Selector \"%s\"\n",args
);
1028 display_selector (current_thread
->h
, sel
);
1032 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
1035 info_w32_command (char *args
, int from_tty
)
1037 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1041 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1042 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1043 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1046 handle_exception (struct target_waitstatus
*ourstatus
)
1049 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1051 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1053 /* Record the context of the current thread */
1054 th
= thread_rec (current_event
.dwThreadId
, -1);
1058 case EXCEPTION_ACCESS_VIOLATION
:
1059 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1060 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1062 case STATUS_STACK_OVERFLOW
:
1063 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1064 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1066 case STATUS_FLOAT_DENORMAL_OPERAND
:
1067 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1068 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1070 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1071 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1072 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1074 case STATUS_FLOAT_INEXACT_RESULT
:
1075 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1076 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1078 case STATUS_FLOAT_INVALID_OPERATION
:
1079 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1080 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1082 case STATUS_FLOAT_OVERFLOW
:
1083 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1084 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1086 case STATUS_FLOAT_STACK_CHECK
:
1087 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1088 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1090 case STATUS_FLOAT_UNDERFLOW
:
1091 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1092 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1094 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1095 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1096 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1098 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1099 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1100 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1102 case STATUS_INTEGER_OVERFLOW
:
1103 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1104 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1106 case EXCEPTION_BREAKPOINT
:
1107 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1108 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1111 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1112 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1114 case DBG_CONTROL_BREAK
:
1115 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1116 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1118 case EXCEPTION_SINGLE_STEP
:
1119 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1120 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1122 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1123 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1124 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1126 case EXCEPTION_PRIV_INSTRUCTION
:
1127 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1128 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1130 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1131 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1132 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1135 if (current_event
.u
.Exception
.dwFirstChance
)
1137 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1138 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1139 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1140 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1144 last_sig
= ourstatus
->value
.sig
;
1148 /* Resume all artificially suspended threads if we are continuing
1151 child_continue (DWORD continue_status
, int id
)
1157 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1158 current_event
.dwProcessId
, current_event
.dwThreadId
,
1159 continue_status
== DBG_CONTINUE
?
1160 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1161 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1162 current_event
.dwThreadId
,
1164 continue_status
= 0;
1166 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1167 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1170 for (i
= 0; i
< th
->suspend_count
; i
++)
1171 (void) ResumeThread (th
->h
);
1172 th
->suspend_count
= 0;
1173 if (debug_registers_changed
)
1175 /* Only change the value of the debug reisters */
1176 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1177 th
->context
.Dr0
= dr
[0];
1178 th
->context
.Dr1
= dr
[1];
1179 th
->context
.Dr2
= dr
[2];
1180 th
->context
.Dr3
= dr
[3];
1181 /* th->context.Dr6 = dr[6];
1182 FIXME: should we set dr6 also ?? */
1183 th
->context
.Dr7
= dr
[7];
1184 CHECK (SetThreadContext (th
->h
, &th
->context
));
1185 th
->context
.ContextFlags
= 0;
1189 debug_registers_changed
= 0;
1193 /* Get the next event from the child. Return 1 if the event requires
1194 handling by WFI (or whatever).
1197 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1200 DWORD continue_status
, event_code
;
1201 thread_info
*th
= NULL
;
1202 static thread_info dummy_thread_info
;
1205 last_sig
= TARGET_SIGNAL_0
;
1207 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1211 continue_status
= DBG_CONTINUE
;
1213 event_code
= current_event
.dwDebugEventCode
;
1214 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1218 case CREATE_THREAD_DEBUG_EVENT
:
1219 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1220 (unsigned) current_event
.dwProcessId
,
1221 (unsigned) current_event
.dwThreadId
,
1222 "CREATE_THREAD_DEBUG_EVENT"));
1223 if (saw_create
!= 1)
1225 /* Record the existence of this thread */
1226 th
= child_add_thread (current_event
.dwThreadId
,
1227 current_event
.u
.CreateThread
.hThread
);
1229 printf_unfiltered ("[New %s]\n",
1231 pid_to_ptid (current_event
.dwThreadId
)));
1232 retval
= current_event
.dwThreadId
;
1235 case EXIT_THREAD_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 "EXIT_THREAD_DEBUG_EVENT"));
1240 if (saw_create
!= 1)
1242 child_delete_thread (current_event
.dwThreadId
);
1243 th
= &dummy_thread_info
;
1246 case CREATE_PROCESS_DEBUG_EVENT
:
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 "CREATE_PROCESS_DEBUG_EVENT"));
1251 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1252 if (++saw_create
!= 1)
1254 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1258 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1259 main_thread_id
= current_event
.dwThreadId
;
1260 /* Add the main thread */
1262 th
= child_add_thread (current_event
.dwProcessId
,
1263 current_event
.u
.CreateProcessInfo
.hProcess
);
1265 th
= child_add_thread (main_thread_id
,
1266 current_event
.u
.CreateProcessInfo
.hThread
);
1267 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1270 case EXIT_PROCESS_DEBUG_EVENT
:
1271 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1272 (unsigned) current_event
.dwProcessId
,
1273 (unsigned) current_event
.dwThreadId
,
1274 "EXIT_PROCESS_DEBUG_EVENT"));
1275 if (saw_create
!= 1)
1277 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1278 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1279 CloseHandle (current_process_handle
);
1280 retval
= main_thread_id
;
1283 case LOAD_DLL_DEBUG_EVENT
:
1284 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1285 (unsigned) current_event
.dwProcessId
,
1286 (unsigned) current_event
.dwThreadId
,
1287 "LOAD_DLL_DEBUG_EVENT"));
1288 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1289 if (saw_create
!= 1)
1291 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1292 registers_changed (); /* mark all regs invalid */
1293 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1294 ourstatus
->value
.integer
= 0;
1295 retval
= main_thread_id
;
1296 re_enable_breakpoints_in_shlibs ();
1299 case UNLOAD_DLL_DEBUG_EVENT
:
1300 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1301 (unsigned) current_event
.dwProcessId
,
1302 (unsigned) current_event
.dwThreadId
,
1303 "UNLOAD_DLL_DEBUG_EVENT"));
1304 if (saw_create
!= 1)
1306 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1307 registers_changed (); /* mark all regs invalid */
1308 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1309 does not exist yet. */
1312 case EXCEPTION_DEBUG_EVENT
:
1313 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1314 (unsigned) current_event
.dwProcessId
,
1315 (unsigned) current_event
.dwThreadId
,
1316 "EXCEPTION_DEBUG_EVENT"));
1317 if (saw_create
!= 1)
1319 if (handle_exception (ourstatus
))
1320 retval
= current_event
.dwThreadId
;
1323 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1324 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1325 (unsigned) current_event
.dwProcessId
,
1326 (unsigned) current_event
.dwThreadId
,
1327 "OUTPUT_DEBUG_STRING_EVENT"));
1328 if (saw_create
!= 1)
1330 if (handle_output_debug_string (ourstatus
))
1331 retval
= main_thread_id
;
1335 if (saw_create
!= 1)
1337 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1338 (DWORD
) current_event
.dwProcessId
,
1339 (DWORD
) current_event
.dwThreadId
);
1340 printf_unfiltered (" unknown event code %ld\n",
1341 current_event
.dwDebugEventCode
);
1345 if (!retval
|| saw_create
!= 1)
1346 CHECK (child_continue (continue_status
, -1));
1349 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1350 inferior_ptid
= pid_to_ptid (retval
);
1357 /* Wait for interesting events to occur in the target process. */
1359 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1361 int pid
= PIDGET (ptid
);
1363 /* We loop when we get a non-standard exception rather than return
1364 with a SPURIOUS because resume can try and step or modify things,
1365 which needs a current_thread->h. But some of these exceptions mark
1366 the birth or death of threads, which mean that the current thread
1367 isn't necessarily what you think it is. */
1371 int retval
= get_child_debug_event (pid
, ourstatus
);
1373 return pid_to_ptid (retval
);
1378 if (ui_loop_hook
!= NULL
)
1379 detach
= ui_loop_hook (0);
1382 child_kill_inferior ();
1388 do_initial_child_stuff (DWORD pid
)
1390 extern int stop_after_trap
;
1393 last_sig
= TARGET_SIGNAL_0
;
1395 exception_count
= 0;
1396 debug_registers_changed
= 0;
1397 debug_registers_used
= 0;
1398 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1400 current_event
.dwProcessId
= pid
;
1401 memset (¤t_event
, 0, sizeof (current_event
));
1402 push_target (&child_ops
);
1403 child_init_thread_list ();
1404 disable_breakpoints_in_shlibs (1);
1405 child_clear_solibs ();
1406 clear_proceed_status ();
1407 init_wait_for_inferior ();
1409 target_terminal_init ();
1410 target_terminal_inferior ();
1414 stop_after_trap
= 1;
1415 wait_for_inferior ();
1416 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1417 resume (0, stop_signal
);
1421 stop_after_trap
= 0;
1425 /* Since Windows XP, detaching from a process is supported by Windows.
1426 The following code tries loading the appropriate functions dynamically.
1427 If loading these functions succeeds use them to actually detach from
1428 the inferior process, otherwise behave as usual, pretending that
1429 detach has worked. */
1430 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1431 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1434 has_detach_ability (void)
1436 static HMODULE kernel32
= NULL
;
1439 kernel32
= LoadLibrary ("kernel32.dll");
1442 if (!DebugSetProcessKillOnExit
)
1443 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1444 "DebugSetProcessKillOnExit");
1445 if (!DebugActiveProcessStop
)
1446 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1447 "DebugActiveProcessStop");
1448 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1454 /* Try to set or remove a user privilege to the current process. Return -1
1455 if that fails, the previous setting of that privilege otherwise.
1457 This code is copied from the Cygwin source code and rearranged to allow
1458 dynamically loading of the needed symbols from advapi32 which is only
1459 available on NT/2K/XP. */
1461 set_process_privilege (const char *privilege
, BOOL enable
)
1463 static HMODULE advapi32
= NULL
;
1464 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1465 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1466 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1467 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1469 HANDLE token_hdl
= NULL
;
1471 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1475 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1480 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1482 if (!OpenProcessToken
)
1483 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1484 if (!LookupPrivilegeValue
)
1485 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1486 "LookupPrivilegeValueA");
1487 if (!AdjustTokenPrivileges
)
1488 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1489 "AdjustTokenPrivileges");
1490 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1497 if (!OpenProcessToken (GetCurrentProcess (),
1498 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1502 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1505 new_priv
.PrivilegeCount
= 1;
1506 new_priv
.Privileges
[0].Luid
= restore_priv
;
1507 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1509 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1510 sizeof orig_priv
, &orig_priv
, &size
))
1513 /* Disabled, otherwise every `attach' in an unprivileged user session
1514 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1516 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1517 be enabled. GetLastError () returns an correct error code, though. */
1518 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1522 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1526 CloseHandle (token_hdl
);
1531 /* Attach to process PID, then initialize for debugging it. */
1533 child_attach (char *args
, int from_tty
)
1539 error_no_arg ("process-id to attach");
1541 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1543 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1544 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1547 pid
= strtoul (args
, 0, 0); /* Windows pid */
1549 ok
= DebugActiveProcess (pid
);
1554 /* Try fall back to Cygwin pid */
1555 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1558 ok
= DebugActiveProcess (pid
);
1561 error ("Can't attach to process.");
1564 if (has_detach_ability ())
1567 DebugSetProcessKillOnExit (FALSE
);
1572 char *exec_file
= (char *) get_exec_file (0);
1575 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1576 target_pid_to_str (pid_to_ptid (pid
)));
1578 printf_unfiltered ("Attaching to %s\n",
1579 target_pid_to_str (pid_to_ptid (pid
)));
1581 gdb_flush (gdb_stdout
);
1584 do_initial_child_stuff (pid
);
1585 target_terminal_ours ();
1589 child_detach (char *args
, int from_tty
)
1593 if (has_detach_ability ())
1595 delete_command (NULL
, 0);
1596 child_continue (DBG_CONTINUE
, -1);
1597 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1599 error ("Can't detach process %lu (error %lu)",
1600 current_event
.dwProcessId
, GetLastError ());
1603 DebugSetProcessKillOnExit (FALSE
);
1605 if (detached
&& from_tty
)
1607 char *exec_file
= get_exec_file (0);
1610 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1611 current_event
.dwProcessId
);
1612 gdb_flush (gdb_stdout
);
1614 inferior_ptid
= null_ptid
;
1615 unpush_target (&child_ops
);
1618 /* Print status information about what we're accessing. */
1621 child_files_info (struct target_ops
*ignore
)
1623 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1624 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1628 child_open (char *arg
, int from_tty
)
1630 error ("Use the \"run\" command to start a Unix child process.");
1633 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1634 EXEC_FILE is the file to run.
1635 ALLARGS is a string containing the arguments to the program.
1636 ENV is the environment vector to pass. Errors reported with error(). */
1639 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1646 PROCESS_INFORMATION pi
;
1650 char real_path
[MAXPATHLEN
];
1652 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1655 int ostdin
, ostdout
, ostderr
;
1658 error ("No executable specified, use `target exec'.\n");
1660 memset (&si
, 0, sizeof (si
));
1661 si
.cb
= sizeof (si
);
1665 flags
= DEBUG_ONLY_THIS_PROCESS
;
1666 cygwin_conv_to_win32_path (exec_file
, real_path
);
1672 sh
= getenv ("SHELL");
1675 cygwin_conv_to_win32_path (sh
, shell
);
1676 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1677 + strlen (allargs
) + 2);
1678 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1679 allargs
= newallargs
;
1681 flags
= DEBUG_PROCESS
;
1685 flags
|= CREATE_NEW_PROCESS_GROUP
;
1688 flags
|= CREATE_NEW_CONSOLE
;
1690 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1691 strcpy (args
, toexec
);
1693 strcat (args
, allargs
);
1695 /* Prepare the environment vars for CreateProcess. */
1697 /* This code used to assume all env vars were file names and would
1698 translate them all to win32 style. That obviously doesn't work in the
1699 general case. The current rule is that we only translate PATH.
1700 We need to handle PATH because we're about to call CreateProcess and
1701 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1702 in both posix and win32 environments. cygwin.dll will change it back
1703 to posix style if necessary. */
1705 static const char *conv_path_names
[] =
1711 /* CreateProcess takes the environment list as a null terminated set of
1712 strings (i.e. two nulls terminate the list). */
1714 /* Get total size for env strings. */
1715 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1719 for (j
= 0; conv_path_names
[j
]; j
++)
1721 len
= strlen (conv_path_names
[j
]);
1722 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1724 if (cygwin_posix_path_list_p (env
[i
] + len
))
1726 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1728 envlen
+= strlen (env
[i
]) + 1;
1732 if (conv_path_names
[j
] == NULL
)
1733 envlen
+= strlen (env
[i
]) + 1;
1736 winenv
= alloca (envlen
+ 1);
1738 /* Copy env strings into new buffer. */
1739 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1743 for (j
= 0; conv_path_names
[j
]; j
++)
1745 len
= strlen (conv_path_names
[j
]);
1746 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1748 if (cygwin_posix_path_list_p (env
[i
] + len
))
1750 memcpy (temp
, env
[i
], len
);
1751 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1754 strcpy (temp
, env
[i
]);
1758 if (conv_path_names
[j
] == NULL
)
1759 strcpy (temp
, env
[i
]);
1761 temp
+= strlen (temp
) + 1;
1764 /* Final nil string to terminate new env. */
1768 if (!inferior_io_terminal
)
1769 tty
= ostdin
= ostdout
= ostderr
= -1;
1772 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1775 print_sys_errmsg (inferior_io_terminal
, errno
);
1776 ostdin
= ostdout
= ostderr
= -1;
1789 ret
= CreateProcess (0,
1790 args
, /* command line */
1791 NULL
, /* Security */
1793 TRUE
, /* inherit handles */
1794 flags
, /* start flags */
1796 NULL
, /* current directory */
1811 error ("Error creating process %s, (error %d)\n", exec_file
, (unsigned) GetLastError ());
1813 CloseHandle (pi
.hThread
);
1814 CloseHandle (pi
.hProcess
);
1816 if (useshell
&& shell
[0] != '\0')
1821 do_initial_child_stuff (pi
.dwProcessId
);
1823 /* child_continue (DBG_CONTINUE, -1); */
1824 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1828 child_mourn_inferior (void)
1830 (void) child_continue (DBG_CONTINUE
, -1);
1831 i386_cleanup_dregs();
1832 unpush_target (&child_ops
);
1833 generic_mourn_inferior ();
1836 /* Send a SIGINT to the process group. This acts just like the user typed a
1837 ^C on the controlling terminal. */
1842 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1843 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1844 registers_changed (); /* refresh register state */
1848 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1849 int write
, struct mem_attrib
*mem
,
1850 struct target_ops
*target
)
1855 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1856 len
, (DWORD
) memaddr
));
1857 if (!WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1860 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1864 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1865 len
, (DWORD
) memaddr
));
1866 if (!ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
,
1874 child_kill_inferior (void)
1876 CHECK (TerminateProcess (current_process_handle
, 0));
1880 if (!child_continue (DBG_CONTINUE
, -1))
1882 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1884 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1888 CHECK (CloseHandle (current_process_handle
));
1890 /* this may fail in an attached process so don't check. */
1891 (void) CloseHandle (current_thread
->h
);
1892 target_mourn_inferior (); /* or just child_mourn_inferior? */
1896 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1899 DWORD continue_status
= DBG_CONTINUE
;
1901 int pid
= PIDGET (ptid
);
1903 if (sig
!= TARGET_SIGNAL_0
)
1905 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1907 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1909 else if (sig
== last_sig
)
1910 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1913 /* This code does not seem to work, because
1914 the kernel does probably not consider changes in the ExceptionRecord
1915 structure when passing the exception to the inferior.
1916 Note that this seems possible in the exception handler itself. */
1919 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1920 if (xlate
[i
].us
== sig
)
1922 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1924 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1927 if (continue_status
== DBG_CONTINUE
)
1929 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1933 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1937 last_sig
= TARGET_SIGNAL_0
;
1939 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1942 /* Get context for currently selected thread */
1943 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1948 /* Single step by setting t bit */
1949 child_fetch_inferior_registers (PS_REGNUM
);
1950 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1953 if (th
->context
.ContextFlags
)
1955 if (debug_registers_changed
)
1957 th
->context
.Dr0
= dr
[0];
1958 th
->context
.Dr1
= dr
[1];
1959 th
->context
.Dr2
= dr
[2];
1960 th
->context
.Dr3
= dr
[3];
1961 /* th->context.Dr6 = dr[6];
1962 FIXME: should we set dr6 also ?? */
1963 th
->context
.Dr7
= dr
[7];
1965 CHECK (SetThreadContext (th
->h
, &th
->context
));
1966 th
->context
.ContextFlags
= 0;
1970 /* Allow continuing with the same signal that interrupted us.
1971 Otherwise complain. */
1973 child_continue (continue_status
, pid
);
1977 child_prepare_to_store (void)
1979 /* Do nothing, since we can store individual regs */
1983 child_can_run (void)
1991 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1992 PIDGET (inferior_ptid
)));
1995 struct target_ops child_ops
;
1998 init_child_ops (void)
2000 child_ops
.to_shortname
= "child";
2001 child_ops
.to_longname
= "Win32 child process";
2002 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2003 child_ops
.to_open
= child_open
;
2004 child_ops
.to_close
= child_close
;
2005 child_ops
.to_attach
= child_attach
;
2006 child_ops
.to_detach
= child_detach
;
2007 child_ops
.to_resume
= child_resume
;
2008 child_ops
.to_wait
= child_wait
;
2009 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
2010 child_ops
.to_store_registers
= child_store_inferior_registers
;
2011 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
2012 child_ops
.to_xfer_memory
= child_xfer_memory
;
2013 child_ops
.to_files_info
= child_files_info
;
2014 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2015 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2016 child_ops
.to_terminal_init
= terminal_init_inferior
;
2017 child_ops
.to_terminal_inferior
= terminal_inferior
;
2018 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2019 child_ops
.to_terminal_ours
= terminal_ours
;
2020 child_ops
.to_terminal_save_ours
= terminal_save_ours
;
2021 child_ops
.to_terminal_info
= child_terminal_info
;
2022 child_ops
.to_kill
= child_kill_inferior
;
2023 child_ops
.to_create_inferior
= child_create_inferior
;
2024 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
2025 child_ops
.to_can_run
= child_can_run
;
2026 child_ops
.to_thread_alive
= win32_child_thread_alive
;
2027 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
2028 child_ops
.to_stop
= child_stop
;
2029 child_ops
.to_stratum
= process_stratum
;
2030 child_ops
.to_has_all_memory
= 1;
2031 child_ops
.to_has_memory
= 1;
2032 child_ops
.to_has_stack
= 1;
2033 child_ops
.to_has_registers
= 1;
2034 child_ops
.to_has_execution
= 1;
2035 child_ops
.to_magic
= OPS_MAGIC
;
2039 _initialize_win32_nat (void)
2041 struct cmd_list_element
*c
;
2045 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2046 "Load dll library symbols from FILE.");
2047 set_cmd_completer (c
, filename_completer
);
2049 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2051 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
2053 "Set use of shell to start subprocess.",
2057 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
2058 (char *) &new_console
,
2059 "Set creation of new console when creating child process.",
2063 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
2064 (char *) &new_group
,
2065 "Set creation of new group when creating child process.",
2069 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
2070 (char *) &debug_exec
,
2071 "Set whether to display execution in child process.",
2075 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
2076 (char *) &debug_events
,
2077 "Set whether to display kernel events in child process.",
2081 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
2082 (char *) &debug_memory
,
2083 "Set whether to display memory accesses in child process.",
2087 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
2088 (char *) &debug_exceptions
,
2089 "Set whether to display kernel exceptions in child process.",
2093 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
2094 add_info_alias ("sharedlibrary", "dll", 1);
2096 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2097 "Print information specific to Win32 debugging.",
2098 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2100 add_cmd ("selector", class_info
, display_selectors
,
2101 "Display selectors infos.",
2104 add_target (&child_ops
);
2107 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2109 /* Pass the address ADDR to the inferior in the I'th debug register.
2110 Here we just store the address in dr array, the registers will be
2111 actually set up when child_continue is called. */
2113 cygwin_set_dr (int i
, CORE_ADDR addr
)
2116 internal_error (__FILE__
, __LINE__
,
2117 "Invalid register %d in cygwin_set_dr.\n", i
);
2118 dr
[i
] = (unsigned) addr
;
2119 debug_registers_changed
= 1;
2120 debug_registers_used
= 1;
2123 /* Pass the value VAL to the inferior in the DR7 debug control
2124 register. Here we just store the address in D_REGS, the watchpoint
2125 will be actually set up in child_wait. */
2127 cygwin_set_dr7 (unsigned val
)
2130 debug_registers_changed
= 1;
2131 debug_registers_used
= 1;
2134 /* Get the value of the DR6 debug status register from the inferior.
2135 Here we just return the value stored in dr[6]
2136 by the last call to thread_rec for current_event.dwThreadId id. */
2138 cygwin_get_dr6 (void)
2144 /* Determine if the thread referenced by "pid" is alive
2145 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2146 it means that the pid has died. Otherwise it is assumed to be alive. */
2148 win32_child_thread_alive (ptid_t ptid
)
2150 int pid
= PIDGET (ptid
);
2152 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2156 /* Convert pid to printable format. */
2158 cygwin_pid_to_str (ptid_t ptid
)
2160 static char buf
[80];
2161 int pid
= PIDGET (ptid
);
2163 if ((DWORD
) pid
== current_event
.dwProcessId
)
2164 sprintf (buf
, "process %d", pid
);
2166 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2171 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
2173 struct objfile
*objfile
;
2174 char *objfile_basename
;
2175 const char *dll_basename
;
2177 if (!(dll_basename
= strrchr (dll_name
, '/')))
2178 dll_basename
= dll_name
;
2182 ALL_OBJFILES (objfile
)
2184 objfile_basename
= strrchr (objfile
->name
, '/');
2186 if (objfile_basename
&&
2187 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
2189 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2190 base_addr
, dll_name
);
2195 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
2196 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
2204 struct target_ops
*target
;
2206 } map_code_section_args
;
2209 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2213 struct section_table
*new_target_sect_ptr
;
2215 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2216 struct target_ops
*target
= args
->target
;
2217 if (sect
->flags
& SEC_CODE
)
2219 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2221 if (target
->to_sections
)
2223 old
= target
->to_sections_end
- target
->to_sections
;
2224 target
->to_sections
= (struct section_table
*)
2225 xrealloc ((char *) target
->to_sections
,
2226 (sizeof (struct section_table
)) * (1 + old
));
2231 target
->to_sections
= (struct section_table
*)
2232 xmalloc ((sizeof (struct section_table
)));
2234 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2236 /* Update the to_sections field in the core_ops structure
2240 core_ops
.to_sections
= target
->to_sections
;
2241 core_ops
.to_sections_end
= target
->to_sections_end
;
2243 new_target_sect_ptr
= target
->to_sections
+ old
;
2244 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2245 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2246 bfd_section_size (abfd
, sect
);;
2247 new_target_sect_ptr
->the_bfd_section
= sect
;
2248 new_target_sect_ptr
->bfd
= abfd
;
2253 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2256 map_code_section_args map_args
;
2257 asection
*lowest_sect
;
2259 if (dll_name
== NULL
|| target
== NULL
)
2261 name
= xstrdup (dll_name
);
2262 dll_bfd
= bfd_openr (name
, "pei-i386");
2263 if (dll_bfd
== NULL
)
2266 if (bfd_check_format (dll_bfd
, bfd_object
))
2268 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2269 if (lowest_sect
== NULL
)
2271 map_args
.target
= target
;
2272 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2274 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2281 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2283 struct target_ops
*target
= (struct target_ops
*) obj
;
2288 char *dll_name
= NULL
;
2290 struct win32_pstatus
*pstatus
;
2293 if (strncmp (sect
->name
, ".module", 7))
2296 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2299 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2302 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2305 pstatus
= (struct win32_pstatus
*) buf
;
2307 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2308 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2309 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2312 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2315 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2318 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2320 while ((p
= strchr (dll_name
, '\\')))
2323 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2324 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2326 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2327 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2338 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2345 child_clear_solibs ();
2346 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2350 if (solib_end
&& solib_end
->name
)
2351 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2352 solib_end
->load_addr
);
2357 fetch_elf_core_registers (char *core_reg_sect
,
2358 unsigned core_reg_size
,
2363 if (core_reg_size
< sizeof (CONTEXT
))
2365 error ("Core file register section too small (%u bytes).", core_reg_size
);
2368 for (r
= 0; r
< NUM_REGS
; r
++)
2369 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2372 static struct core_fns win32_elf_core_fns
=
2374 bfd_target_elf_flavour
,
2375 default_check_format
,
2376 default_core_sniffer
,
2377 fetch_elf_core_registers
,
2382 _initialize_core_win32 (void)
2384 add_core_fns (&win32_elf_core_fns
);
2388 _initialize_check_for_gdb_ini (void)
2391 if (inhibit_gdbinit
)
2394 homedir
= getenv ("HOME");
2398 char *oldini
= (char *) alloca (strlen (homedir
) +
2399 sizeof ("/gdb.ini"));
2400 strcpy (oldini
, homedir
);
2401 p
= strchr (oldini
, '\0');
2402 if (p
> oldini
&& p
[-1] != '/')
2404 strcpy (p
, "gdb.ini");
2405 if (access (oldini
, 0) == 0)
2407 int len
= strlen (oldini
);
2408 char *newini
= alloca (len
+ 1);
2409 sprintf (newini
, "%.*s.gdbinit",
2410 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2411 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);