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>
56 /* The ui's event loop. */
57 extern int (*ui_loop_hook
) (int signo
);
59 /* If we're not using the old Cygwin header file set, define the
60 following which never should have been in the generic Win32 API
61 headers in the first place since they were our own invention... */
62 #ifndef _GNU_H_WINDOWS_H
65 FLAG_TRACE_BIT
= 0x100,
66 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
69 #include <sys/procfs.h>
72 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
73 | CONTEXT_EXTENDED_REGISTERS
75 static unsigned dr
[8];
76 static int debug_registers_changed
= 0;
77 static int debug_registers_used
= 0;
79 /* The string sent by cygwin when it processes a signal.
80 FIXME: This should be in a cygwin include file. */
81 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
83 #define CHECK(x) check (x, __FILE__,__LINE__)
84 #define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
85 #define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x
86 #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
87 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
89 /* Forward declaration */
90 extern struct target_ops child_ops
;
92 static void child_stop (void);
93 static int win32_child_thread_alive (ptid_t
);
94 void child_kill_inferior (void);
96 static enum target_signal last_sig
= TARGET_SIGNAL_0
;
97 /* Set if a signal was received from the debugged process */
99 /* Thread information structure used to track information that is
100 not available in gdb's thread structure. */
101 typedef struct thread_info_struct
103 struct thread_info_struct
*next
;
113 static thread_info thread_head
;
115 /* The process and thread handles for the above context. */
117 static DEBUG_EVENT current_event
; /* The current debug event from
119 static HANDLE current_process_handle
; /* Currently executing process */
120 static thread_info
*current_thread
; /* Info on currently selected thread */
121 static DWORD main_thread_id
; /* Thread ID of the main thread */
123 /* Counts of things. */
124 static int exception_count
= 0;
125 static int event_count
= 0;
126 static int saw_create
;
129 static int new_console
= 0;
130 static int new_group
= 1;
131 static int debug_exec
= 0; /* show execution */
132 static int debug_events
= 0; /* show events from kernel */
133 static int debug_memory
= 0; /* show target memory accesses */
134 static int debug_exceptions
= 0; /* show target exceptions */
135 static int useshell
= 0; /* use shell for subprocesses */
137 /* This vector maps GDB's idea of a register's number into an address
138 in the win32 exception context vector.
140 It also contains the bit mask needed to load the register in question.
142 One day we could read a reg, we could inspect the context we
143 already have loaded, if it doesn't have the bit set that we need,
144 we read that set of registers in using GetThreadContext. If the
145 context already contains what we need, we just unpack it. Then to
146 write a register, first we have to ensure that the context contains
147 the other regs of the group, and then we copy the info in and set
150 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
151 static const int mappings
[] =
153 context_offset (Eax
),
154 context_offset (Ecx
),
155 context_offset (Edx
),
156 context_offset (Ebx
),
157 context_offset (Esp
),
158 context_offset (Ebp
),
159 context_offset (Esi
),
160 context_offset (Edi
),
161 context_offset (Eip
),
162 context_offset (EFlags
),
163 context_offset (SegCs
),
164 context_offset (SegSs
),
165 context_offset (SegDs
),
166 context_offset (SegEs
),
167 context_offset (SegFs
),
168 context_offset (SegGs
),
169 context_offset (FloatSave
.RegisterArea
[0 * 10]),
170 context_offset (FloatSave
.RegisterArea
[1 * 10]),
171 context_offset (FloatSave
.RegisterArea
[2 * 10]),
172 context_offset (FloatSave
.RegisterArea
[3 * 10]),
173 context_offset (FloatSave
.RegisterArea
[4 * 10]),
174 context_offset (FloatSave
.RegisterArea
[5 * 10]),
175 context_offset (FloatSave
.RegisterArea
[6 * 10]),
176 context_offset (FloatSave
.RegisterArea
[7 * 10]),
177 context_offset (FloatSave
.ControlWord
),
178 context_offset (FloatSave
.StatusWord
),
179 context_offset (FloatSave
.TagWord
),
180 context_offset (FloatSave
.ErrorSelector
),
181 context_offset (FloatSave
.ErrorOffset
),
182 context_offset (FloatSave
.DataSelector
),
183 context_offset (FloatSave
.DataOffset
),
184 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])
200 #undef context_offset
202 /* This vector maps the target's idea of an exception (extracted
203 from the DEBUG_EVENT structure) to GDB's idea. */
205 struct xlate_exception
208 enum target_signal us
;
211 static const struct xlate_exception
214 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
215 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
216 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
217 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
218 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
219 {STATUS_FLOAT_DIVIDE_BY_ZERO
, TARGET_SIGNAL_FPE
},
223 check (BOOL ok
, const char *file
, int line
)
226 printf_filtered ("error return %s:%d was %lu\n", file
, line
,
231 /* Find a thread record given a thread id.
232 If get_context then also retrieve the context for this
235 thread_rec (DWORD id
, int get_context
)
239 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
242 if (!th
->suspend_count
&& get_context
)
244 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
245 th
->suspend_count
= SuspendThread (th
->h
) + 1;
246 else if (get_context
< 0)
247 th
->suspend_count
= -1;
249 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
250 GetThreadContext (th
->h
, &th
->context
);
251 if (id
== current_event
.dwThreadId
)
253 /* Copy dr values from that thread. */
254 dr
[0] = th
->context
.Dr0
;
255 dr
[1] = th
->context
.Dr1
;
256 dr
[2] = th
->context
.Dr2
;
257 dr
[3] = th
->context
.Dr3
;
258 dr
[6] = th
->context
.Dr6
;
259 dr
[7] = th
->context
.Dr7
;
268 /* Add a thread to the thread list */
270 child_add_thread (DWORD id
, HANDLE h
)
274 if ((th
= thread_rec (id
, FALSE
)))
277 th
= (thread_info
*) xmalloc (sizeof (*th
));
278 memset (th
, 0, sizeof (*th
));
281 th
->next
= thread_head
.next
;
282 thread_head
.next
= th
;
283 add_thread (pid_to_ptid (id
));
284 /* Set the debug registers for the new thread in they are used. */
285 if (debug_registers_used
)
287 /* Only change the value of the debug registers. */
288 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
289 CHECK (GetThreadContext (th
->h
, &th
->context
));
290 th
->context
.Dr0
= dr
[0];
291 th
->context
.Dr1
= dr
[1];
292 th
->context
.Dr2
= dr
[2];
293 th
->context
.Dr3
= dr
[3];
294 /* th->context.Dr6 = dr[6];
295 FIXME: should we set dr6 also ?? */
296 th
->context
.Dr7
= dr
[7];
297 CHECK (SetThreadContext (th
->h
, &th
->context
));
298 th
->context
.ContextFlags
= 0;
303 /* Clear out any old thread list and reintialize it to a
306 child_init_thread_list (void)
308 thread_info
*th
= &thread_head
;
310 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
312 while (th
->next
!= NULL
)
314 thread_info
*here
= th
->next
;
315 th
->next
= here
->next
;
316 (void) CloseHandle (here
->h
);
321 /* Delete a thread from the list of threads */
323 child_delete_thread (DWORD id
)
328 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
329 delete_thread (pid_to_ptid (id
));
331 for (th
= &thread_head
;
332 th
->next
!= NULL
&& th
->next
->id
!= id
;
336 if (th
->next
!= NULL
)
338 thread_info
*here
= th
->next
;
339 th
->next
= here
->next
;
340 CloseHandle (here
->h
);
346 do_child_fetch_inferior_registers (int r
)
348 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
352 l
= *((long *) context_offset
) & 0xffff;
353 supply_register (r
, (char *) &l
);
355 else if (r
== FOP_REGNUM
)
357 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
358 supply_register (r
, (char *) &l
);
361 supply_register (r
, context_offset
);
364 for (r
= 0; r
< NUM_REGS
; r
++)
365 do_child_fetch_inferior_registers (r
);
370 child_fetch_inferior_registers (int r
)
372 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
373 do_child_fetch_inferior_registers (r
);
377 do_child_store_inferior_registers (int r
)
380 regcache_collect (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
383 for (r
= 0; r
< NUM_REGS
; r
++)
384 do_child_store_inferior_registers (r
);
388 /* Store a new register value into the current thread context */
390 child_store_inferior_registers (int r
)
392 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
393 do_child_store_inferior_registers (r
);
396 static int psapi_loaded
= 0;
397 static HMODULE psapi_module_handle
= NULL
;
398 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
399 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
400 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
403 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
409 HMODULE
*DllHandle
= dh_buf
;
414 psapi_EnumProcessModules
== NULL
||
415 psapi_GetModuleInformation
== NULL
||
416 psapi_GetModuleFileNameExA
== NULL
)
421 psapi_module_handle
= LoadLibrary ("psapi.dll");
422 if (!psapi_module_handle
)
424 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
427 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
428 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
429 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
430 "GetModuleFileNameExA");
431 if (psapi_EnumProcessModules
== NULL
||
432 psapi_GetModuleInformation
== NULL
||
433 psapi_GetModuleFileNameExA
== NULL
)
438 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
443 if (!ok
|| !cbNeeded
)
446 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
450 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
457 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
459 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
463 error ("Can't get module info");
465 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
470 error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
472 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
477 dll_name_ret
[0] = '\0';
481 /* Encapsulate the information required in a call to
482 symbol_file_add_args */
483 struct safe_symbol_file_add_args
487 struct section_addr_info
*addrs
;
490 struct ui_file
*err
, *out
;
494 /* Maintain a linked list of "so" information. */
497 struct so_stuff
*next
;
501 struct objfile
*objfile
;
503 } solib_start
, *solib_end
;
505 /* Call symbol_file_add with stderr redirected. We don't care if there
508 safe_symbol_file_add_stub (void *argv
)
510 #define p ((struct safe_symbol_file_add_args *)argv)
511 struct so_stuff
*so
= &solib_start
;
513 while ((so
= so
->next
))
514 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
516 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
521 /* Restore gdb's stderr after calling symbol_file_add */
523 safe_symbol_file_add_cleanup (void *p
)
525 #define sp ((struct safe_symbol_file_add_args *)p)
526 gdb_flush (gdb_stderr
);
527 gdb_flush (gdb_stdout
);
528 ui_file_delete (gdb_stderr
);
529 ui_file_delete (gdb_stdout
);
530 gdb_stderr
= sp
->err
;
531 gdb_stdout
= sp
->out
;
535 /* symbol_file_add wrapper that prevents errors from being displayed. */
536 static struct objfile
*
537 safe_symbol_file_add (char *name
, int from_tty
,
538 struct section_addr_info
*addrs
,
539 int mainline
, int flags
)
541 struct safe_symbol_file_add_args p
;
542 struct cleanup
*cleanup
;
544 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
548 gdb_flush (gdb_stderr
);
549 gdb_flush (gdb_stdout
);
550 gdb_stderr
= ui_file_new ();
551 gdb_stdout
= ui_file_new ();
553 p
.from_tty
= from_tty
;
555 p
.mainline
= mainline
;
557 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
559 do_cleanups (cleanup
);
563 /* Remember the maximum DLL length for printing in info dll command. */
564 int max_dll_name_len
;
567 register_loaded_dll (const char *name
, DWORD load_addr
)
570 char ppath
[MAX_PATH
+ 1];
571 char buf
[MAX_PATH
+ 1];
572 char cwd
[MAX_PATH
+ 1];
574 WIN32_FIND_DATA w32_fd
;
575 HANDLE h
= FindFirstFile(name
, &w32_fd
);
576 MEMORY_BASIC_INFORMATION m
;
579 if (h
== INVALID_HANDLE_VALUE
)
585 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
587 p
= strrchr (buf
, '\\');
590 SetCurrentDirectory (buf
);
591 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
592 SetCurrentDirectory (cwd
);
596 cygwin_conv_to_posix_path (buf
, ppath
);
597 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
599 so
->load_addr
= load_addr
;
600 if (VirtualQueryEx (current_process_handle
, (void *) load_addr
, &m
,
602 so
->end_addr
= (DWORD
) m
.AllocationBase
+ m
.RegionSize
;
604 so
->end_addr
= load_addr
+ 0x2000; /* completely arbitrary */
608 strcpy (so
->name
, ppath
);
610 solib_end
->next
= so
;
612 len
= strlen (ppath
);
613 if (len
> max_dll_name_len
)
614 max_dll_name_len
= len
;
618 get_image_name (HANDLE h
, void *address
, int unicode
)
620 static char buf
[(2 * MAX_PATH
) + 1];
621 DWORD size
= unicode
? sizeof (WCHAR
) : sizeof (char);
627 /* Attempt to read the name of the dll that was detected.
628 This is documented to work only when actively debugging
629 a program. It will not work for attached processes. */
633 /* See if we could read the address of a string, and that the
634 address isn't null. */
635 if (!ReadProcessMemory (h
, address
, &address_ptr
, sizeof (address_ptr
), &done
)
636 || done
!= sizeof (address_ptr
) || !address_ptr
)
639 /* Find the length of the string */
640 while (ReadProcessMemory (h
, address_ptr
+ len
++ * size
, &b
, size
, &done
)
641 && (b
[0] != 0 || b
[size
- 1] != 0) && done
== size
)
645 ReadProcessMemory (h
, address_ptr
, buf
, len
, &done
);
648 WCHAR
*unicode_address
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
649 ReadProcessMemory (h
, address_ptr
, unicode_address
, len
* sizeof (WCHAR
),
652 WideCharToMultiByte (CP_ACP
, 0, unicode_address
, len
, buf
, len
, 0, 0);
658 /* Wait for child to do something. Return pid of child, or -1 in case
659 of error; store status through argument pointer OURSTATUS. */
661 handle_load_dll (void *dummy
)
663 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
664 char dll_buf
[MAX_PATH
+ 1];
665 char *dll_name
= NULL
;
668 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
670 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
671 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
675 if (*dll_name
== '\0')
676 dll_name
= get_image_name (current_process_handle
, event
->lpImageName
, event
->fUnicode
);
680 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
686 handle_unload_dll (void *dummy
)
688 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
691 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
692 if (so
->next
->load_addr
== lpBaseOfDll
)
694 struct so_stuff
*sodel
= so
->next
;
695 so
->next
= sodel
->next
;
699 free_objfile (sodel
->objfile
);
703 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
709 solib_address (CORE_ADDR address
)
712 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
713 if (address
>= so
->load_addr
&& address
<= so
->end_addr
)
718 /* Return name of last loaded DLL. */
720 child_solib_loaded_library_pathname (int pid
)
722 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
725 /* Clear list of loaded DLLs. */
727 child_clear_solibs (void)
729 struct so_stuff
*so
, *so1
= solib_start
.next
;
731 while ((so
= so1
) != NULL
)
737 solib_start
.next
= NULL
;
738 solib_start
.objfile
= NULL
;
739 solib_end
= &solib_start
;
740 max_dll_name_len
= sizeof ("DLL Name") - 1;
743 /* Get the loaded address of all sections, given that .text was loaded
744 at text_load. Assumes that all sections are subject to the same
745 relocation offset. Returns NULL if problems occur or if the
746 sections were not relocated. */
748 static struct section_addr_info
*
749 get_relocated_section_addrs (bfd
*abfd
, CORE_ADDR text_load
)
751 struct section_addr_info
*result
= NULL
;
752 int section_count
= bfd_count_sections (abfd
);
753 asection
*text_section
= bfd_get_section_by_name (abfd
, ".text");
758 /* Couldn't get the .text section. Weird. */
761 else if (text_load
== (text_vma
= bfd_get_section_vma (abfd
, text_section
)))
763 /* DLL wasn't relocated. */
768 /* Figure out all sections' loaded addresses. The offset here is
769 such that taking a bfd_get_section_vma() result and adding
770 offset will give the real load address of the section. */
772 CORE_ADDR offset
= text_load
- text_vma
;
774 struct section_table
*table_start
= NULL
;
775 struct section_table
*table_end
= NULL
;
776 struct section_table
*iter
= NULL
;
778 build_section_table (abfd
, &table_start
, &table_end
);
780 for (iter
= table_start
; iter
< table_end
; ++iter
)
782 /* Relocated addresses. */
783 iter
->addr
+= offset
;
784 iter
->endaddr
+= offset
;
787 result
= build_section_addr_info_from_section_table (table_start
,
796 /* Add DLL symbol information. */
797 static struct objfile
*
798 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
800 struct section_addr_info
*addrs
= NULL
;
801 static struct objfile
*result
= NULL
;
804 /* The symbols in a dll are offset by 0x1000, which is the
805 the offset from 0 of the first byte in an image - because
806 of the file header and the section alignment. */
808 if (!name
|| !name
[0])
811 abfd
= bfd_openr (name
, "pei-i386");
815 /* pei failed - try pe */
816 abfd
= bfd_openr (name
, "pe-i386");
821 if (bfd_check_format (abfd
, bfd_object
))
823 addrs
= get_relocated_section_addrs (abfd
, load_addr
);
831 result
= safe_symbol_file_add (name
, from_tty
, addrs
, 0, OBJF_SHARED
);
832 free_section_addr_info (addrs
);
836 /* Fallback on handling just the .text section. */
837 struct cleanup
*my_cleanups
;
839 addrs
= alloc_section_addr_info (1);
840 my_cleanups
= make_cleanup (xfree
, addrs
);
841 addrs
->other
[0].name
= ".text";
842 addrs
->other
[0].addr
= load_addr
;
844 result
= safe_symbol_file_add (name
, from_tty
, addrs
, 0, OBJF_SHARED
);
845 do_cleanups (my_cleanups
);
851 /* Load DLL symbol info. */
853 dll_symbol_command (char *args
, int from_tty
)
859 error ("dll-symbols requires a file name");
862 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
864 char *newargs
= (char *) alloca (n
+ 4 + 1);
865 strcpy (newargs
, args
);
866 strcat (newargs
, ".dll");
870 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
873 /* List currently loaded DLLs. */
875 info_dll_command (char *ignore
, int from_tty
)
877 struct so_stuff
*so
= &solib_start
;
882 printf_filtered ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
883 while ((so
= so
->next
) != NULL
)
884 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
889 /* Handle DEBUG_STRING output from child process.
890 Cygwin prepends its messages with a "cygwin:". Interpret this as
891 a Cygwin signal. Otherwise just print the string as a warning. */
893 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
898 if (!target_read_string
899 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
903 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
905 if (strncmp (s
, "cYg", 3) != 0)
911 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
912 gotasig
= target_signal_from_host (sig
);
913 ourstatus
->value
.sig
= gotasig
;
915 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
923 display_selector (HANDLE thread
, DWORD sel
)
926 if (GetThreadSelectorEntry (thread
, sel
, &info
))
929 printf_filtered ("0x%03lx: ", sel
);
930 if (!info
.HighWord
.Bits
.Pres
)
932 puts_filtered ("Segment not present\n");
935 base
= (info
.HighWord
.Bits
.BaseHi
<< 24) +
936 (info
.HighWord
.Bits
.BaseMid
<< 16)
938 limit
= (info
.HighWord
.Bits
.LimitHi
<< 16) + info
.LimitLow
;
939 if (info
.HighWord
.Bits
.Granularity
)
940 limit
= (limit
<< 12) | 0xfff;
941 printf_filtered ("base=0x%08x limit=0x%08x", base
, limit
);
942 if (info
.HighWord
.Bits
.Default_Big
)
943 puts_filtered(" 32-bit ");
945 puts_filtered(" 16-bit ");
946 switch ((info
.HighWord
.Bits
.Type
& 0xf) >> 1)
949 puts_filtered ("Data (Read-Only, Exp-up");
952 puts_filtered ("Data (Read/Write, Exp-up");
955 puts_filtered ("Unused segment (");
958 puts_filtered ("Data (Read/Write, Exp-down");
961 puts_filtered ("Code (Exec-Only, N.Conf");
964 puts_filtered ("Code (Exec/Read, N.Conf");
967 puts_filtered ("Code (Exec-Only, Conf");
970 puts_filtered ("Code (Exec/Read, Conf");
973 printf_filtered ("Unknown type 0x%x",info
.HighWord
.Bits
.Type
);
975 if ((info
.HighWord
.Bits
.Type
& 0x1) == 0)
976 puts_filtered(", N.Acc");
977 puts_filtered (")\n");
978 if ((info
.HighWord
.Bits
.Type
& 0x10) == 0)
979 puts_filtered("System selector ");
980 printf_filtered ("Priviledge level = %d. ", info
.HighWord
.Bits
.Dpl
);
981 if (info
.HighWord
.Bits
.Granularity
)
982 puts_filtered ("Page granular.\n");
984 puts_filtered ("Byte granular.\n");
989 printf_filtered ("Invalid selector 0x%lx.\n",sel
);
995 display_selectors (char * args
, int from_tty
)
999 puts_filtered ("Impossible to display selectors now.\n");
1005 puts_filtered ("Selector $cs\n");
1006 display_selector (current_thread
->h
,
1007 current_thread
->context
.SegCs
);
1008 puts_filtered ("Selector $ds\n");
1009 display_selector (current_thread
->h
,
1010 current_thread
->context
.SegDs
);
1011 puts_filtered ("Selector $es\n");
1012 display_selector (current_thread
->h
,
1013 current_thread
->context
.SegEs
);
1014 puts_filtered ("Selector $ss\n");
1015 display_selector (current_thread
->h
,
1016 current_thread
->context
.SegSs
);
1017 puts_filtered ("Selector $fs\n");
1018 display_selector (current_thread
->h
,
1019 current_thread
->context
.SegFs
);
1020 puts_filtered ("Selector $gs\n");
1021 display_selector (current_thread
->h
,
1022 current_thread
->context
.SegGs
);
1027 sel
= parse_and_eval_long (args
);
1028 printf_filtered ("Selector \"%s\"\n",args
);
1029 display_selector (current_thread
->h
, sel
);
1033 static struct cmd_list_element
*info_w32_cmdlist
= NULL
;
1036 info_w32_command (char *args
, int from_tty
)
1038 help_list (info_w32_cmdlist
, "info w32 ", class_info
, gdb_stdout
);
1042 #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
1043 printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1044 (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1047 handle_exception (struct target_waitstatus
*ourstatus
)
1050 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
1052 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1054 /* Record the context of the current thread */
1055 th
= thread_rec (current_event
.dwThreadId
, -1);
1059 case EXCEPTION_ACCESS_VIOLATION
:
1060 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1061 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1063 case STATUS_STACK_OVERFLOW
:
1064 DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1065 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
1067 case STATUS_FLOAT_DENORMAL_OPERAND
:
1068 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1069 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1071 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
1072 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1073 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1075 case STATUS_FLOAT_INEXACT_RESULT
:
1076 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1077 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1079 case STATUS_FLOAT_INVALID_OPERATION
:
1080 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1081 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1083 case STATUS_FLOAT_OVERFLOW
:
1084 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1085 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1087 case STATUS_FLOAT_STACK_CHECK
:
1088 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1089 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1091 case STATUS_FLOAT_UNDERFLOW
:
1092 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1093 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1095 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
1096 DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1097 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1099 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
1100 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1101 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1103 case STATUS_INTEGER_OVERFLOW
:
1104 DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1105 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
1107 case EXCEPTION_BREAKPOINT
:
1108 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1109 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1112 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1113 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1115 case DBG_CONTROL_BREAK
:
1116 DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1117 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
1119 case EXCEPTION_SINGLE_STEP
:
1120 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1121 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
1123 case EXCEPTION_ILLEGAL_INSTRUCTION
:
1124 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1125 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1127 case EXCEPTION_PRIV_INSTRUCTION
:
1128 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1129 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1131 case EXCEPTION_NONCONTINUABLE_EXCEPTION
:
1132 DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1133 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
1136 if (current_event
.u
.Exception
.dwFirstChance
)
1138 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1139 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
1140 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
1141 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1145 last_sig
= ourstatus
->value
.sig
;
1149 /* Resume all artificially suspended threads if we are continuing
1152 child_continue (DWORD continue_status
, int id
)
1158 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1159 current_event
.dwProcessId
, current_event
.dwThreadId
,
1160 continue_status
== DBG_CONTINUE
?
1161 "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1162 res
= ContinueDebugEvent (current_event
.dwProcessId
,
1163 current_event
.dwThreadId
,
1165 continue_status
= 0;
1167 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
1168 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
1171 for (i
= 0; i
< th
->suspend_count
; i
++)
1172 (void) ResumeThread (th
->h
);
1173 th
->suspend_count
= 0;
1174 if (debug_registers_changed
)
1176 /* Only change the value of the debug reisters */
1177 th
->context
.ContextFlags
= CONTEXT_DEBUG_REGISTERS
;
1178 th
->context
.Dr0
= dr
[0];
1179 th
->context
.Dr1
= dr
[1];
1180 th
->context
.Dr2
= dr
[2];
1181 th
->context
.Dr3
= dr
[3];
1182 /* th->context.Dr6 = dr[6];
1183 FIXME: should we set dr6 also ?? */
1184 th
->context
.Dr7
= dr
[7];
1185 CHECK (SetThreadContext (th
->h
, &th
->context
));
1186 th
->context
.ContextFlags
= 0;
1190 debug_registers_changed
= 0;
1194 /* Get the next event from the child. Return 1 if the event requires
1195 handling by WFI (or whatever).
1198 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
1201 DWORD continue_status
, event_code
;
1202 thread_info
*th
= NULL
;
1203 static thread_info dummy_thread_info
;
1206 last_sig
= TARGET_SIGNAL_0
;
1208 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
1212 continue_status
= DBG_CONTINUE
;
1214 event_code
= current_event
.dwDebugEventCode
;
1215 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
1219 case CREATE_THREAD_DEBUG_EVENT
:
1220 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1221 (unsigned) current_event
.dwProcessId
,
1222 (unsigned) current_event
.dwThreadId
,
1223 "CREATE_THREAD_DEBUG_EVENT"));
1224 if (saw_create
!= 1)
1226 /* Record the existence of this thread */
1227 th
= child_add_thread (current_event
.dwThreadId
,
1228 current_event
.u
.CreateThread
.hThread
);
1230 printf_unfiltered ("[New %s]\n",
1232 pid_to_ptid (current_event
.dwThreadId
)));
1233 retval
= current_event
.dwThreadId
;
1236 case EXIT_THREAD_DEBUG_EVENT
:
1237 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1238 (unsigned) current_event
.dwProcessId
,
1239 (unsigned) current_event
.dwThreadId
,
1240 "EXIT_THREAD_DEBUG_EVENT"));
1241 if (saw_create
!= 1)
1243 child_delete_thread (current_event
.dwThreadId
);
1244 th
= &dummy_thread_info
;
1247 case CREATE_PROCESS_DEBUG_EVENT
:
1248 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1249 (unsigned) current_event
.dwProcessId
,
1250 (unsigned) current_event
.dwThreadId
,
1251 "CREATE_PROCESS_DEBUG_EVENT"));
1252 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
1253 if (++saw_create
!= 1)
1255 CloseHandle (current_event
.u
.CreateProcessInfo
.hProcess
);
1259 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
1260 main_thread_id
= current_event
.dwThreadId
;
1261 /* Add the main thread */
1263 th
= child_add_thread (current_event
.dwProcessId
,
1264 current_event
.u
.CreateProcessInfo
.hProcess
);
1266 th
= child_add_thread (main_thread_id
,
1267 current_event
.u
.CreateProcessInfo
.hThread
);
1268 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
1271 case EXIT_PROCESS_DEBUG_EVENT
:
1272 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1273 (unsigned) current_event
.dwProcessId
,
1274 (unsigned) current_event
.dwThreadId
,
1275 "EXIT_PROCESS_DEBUG_EVENT"));
1276 if (saw_create
!= 1)
1278 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1279 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
1280 CloseHandle (current_process_handle
);
1281 retval
= main_thread_id
;
1284 case LOAD_DLL_DEBUG_EVENT
:
1285 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1286 (unsigned) current_event
.dwProcessId
,
1287 (unsigned) current_event
.dwThreadId
,
1288 "LOAD_DLL_DEBUG_EVENT"));
1289 CloseHandle (current_event
.u
.LoadDll
.hFile
);
1290 if (saw_create
!= 1)
1292 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1293 registers_changed (); /* mark all regs invalid */
1294 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
1295 ourstatus
->value
.integer
= 0;
1296 retval
= main_thread_id
;
1297 re_enable_breakpoints_in_shlibs ();
1300 case UNLOAD_DLL_DEBUG_EVENT
:
1301 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1302 (unsigned) current_event
.dwProcessId
,
1303 (unsigned) current_event
.dwThreadId
,
1304 "UNLOAD_DLL_DEBUG_EVENT"));
1305 if (saw_create
!= 1)
1307 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
1308 registers_changed (); /* mark all regs invalid */
1309 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1310 does not exist yet. */
1313 case EXCEPTION_DEBUG_EVENT
:
1314 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1315 (unsigned) current_event
.dwProcessId
,
1316 (unsigned) current_event
.dwThreadId
,
1317 "EXCEPTION_DEBUG_EVENT"));
1318 if (saw_create
!= 1)
1320 if (handle_exception (ourstatus
))
1321 retval
= current_event
.dwThreadId
;
1324 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1325 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1326 (unsigned) current_event
.dwProcessId
,
1327 (unsigned) current_event
.dwThreadId
,
1328 "OUTPUT_DEBUG_STRING_EVENT"));
1329 if (saw_create
!= 1)
1331 if (handle_output_debug_string (ourstatus
))
1332 retval
= main_thread_id
;
1336 if (saw_create
!= 1)
1338 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1339 (DWORD
) current_event
.dwProcessId
,
1340 (DWORD
) current_event
.dwThreadId
);
1341 printf_unfiltered (" unknown event code %ld\n",
1342 current_event
.dwDebugEventCode
);
1346 if (!retval
|| saw_create
!= 1)
1347 CHECK (child_continue (continue_status
, -1));
1350 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1351 inferior_ptid
= pid_to_ptid (retval
);
1358 /* Wait for interesting events to occur in the target process. */
1360 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1362 int pid
= PIDGET (ptid
);
1364 /* We loop when we get a non-standard exception rather than return
1365 with a SPURIOUS because resume can try and step or modify things,
1366 which needs a current_thread->h. But some of these exceptions mark
1367 the birth or death of threads, which mean that the current thread
1368 isn't necessarily what you think it is. */
1372 int retval
= get_child_debug_event (pid
, ourstatus
);
1374 return pid_to_ptid (retval
);
1379 if (ui_loop_hook
!= NULL
)
1380 detach
= ui_loop_hook (0);
1383 child_kill_inferior ();
1389 do_initial_child_stuff (DWORD pid
)
1391 extern int stop_after_trap
;
1394 last_sig
= TARGET_SIGNAL_0
;
1396 exception_count
= 0;
1397 debug_registers_changed
= 0;
1398 debug_registers_used
= 0;
1399 for (i
= 0; i
< sizeof (dr
) / sizeof (dr
[0]); i
++)
1401 current_event
.dwProcessId
= pid
;
1402 memset (¤t_event
, 0, sizeof (current_event
));
1403 push_target (&child_ops
);
1404 child_init_thread_list ();
1405 disable_breakpoints_in_shlibs (1);
1406 child_clear_solibs ();
1407 clear_proceed_status ();
1408 init_wait_for_inferior ();
1410 target_terminal_init ();
1411 target_terminal_inferior ();
1415 stop_after_trap
= 1;
1416 wait_for_inferior ();
1417 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1418 resume (0, stop_signal
);
1422 stop_after_trap
= 0;
1426 /* Since Windows XP, detaching from a process is supported by Windows.
1427 The following code tries loading the appropriate functions dynamically.
1428 If loading these functions succeeds use them to actually detach from
1429 the inferior process, otherwise behave as usual, pretending that
1430 detach has worked. */
1431 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1432 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1435 has_detach_ability (void)
1437 static HMODULE kernel32
= NULL
;
1440 kernel32
= LoadLibrary ("kernel32.dll");
1443 if (!DebugSetProcessKillOnExit
)
1444 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1445 "DebugSetProcessKillOnExit");
1446 if (!DebugActiveProcessStop
)
1447 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1448 "DebugActiveProcessStop");
1449 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1455 /* Try to set or remove a user privilege to the current process. Return -1
1456 if that fails, the previous setting of that privilege otherwise.
1458 This code is copied from the Cygwin source code and rearranged to allow
1459 dynamically loading of the needed symbols from advapi32 which is only
1460 available on NT/2K/XP. */
1462 set_process_privilege (const char *privilege
, BOOL enable
)
1464 static HMODULE advapi32
= NULL
;
1465 static BOOL
WINAPI (*OpenProcessToken
)(HANDLE
, DWORD
, PHANDLE
);
1466 static BOOL
WINAPI (*LookupPrivilegeValue
)(LPCSTR
, LPCSTR
, PLUID
);
1467 static BOOL
WINAPI (*AdjustTokenPrivileges
)(HANDLE
, BOOL
, PTOKEN_PRIVILEGES
,
1468 DWORD
, PTOKEN_PRIVILEGES
, PDWORD
);
1470 HANDLE token_hdl
= NULL
;
1472 TOKEN_PRIVILEGES new_priv
, orig_priv
;
1476 if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
1481 if (!(advapi32
= LoadLibrary ("advapi32.dll")))
1483 if (!OpenProcessToken
)
1484 OpenProcessToken
= GetProcAddress (advapi32
, "OpenProcessToken");
1485 if (!LookupPrivilegeValue
)
1486 LookupPrivilegeValue
= GetProcAddress (advapi32
,
1487 "LookupPrivilegeValueA");
1488 if (!AdjustTokenPrivileges
)
1489 AdjustTokenPrivileges
= GetProcAddress (advapi32
,
1490 "AdjustTokenPrivileges");
1491 if (!OpenProcessToken
|| !LookupPrivilegeValue
|| !AdjustTokenPrivileges
)
1498 if (!OpenProcessToken (GetCurrentProcess (),
1499 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
1503 if (!LookupPrivilegeValue (NULL
, privilege
, &restore_priv
))
1506 new_priv
.PrivilegeCount
= 1;
1507 new_priv
.Privileges
[0].Luid
= restore_priv
;
1508 new_priv
.Privileges
[0].Attributes
= enable
? SE_PRIVILEGE_ENABLED
: 0;
1510 if (!AdjustTokenPrivileges (token_hdl
, FALSE
, &new_priv
,
1511 sizeof orig_priv
, &orig_priv
, &size
))
1514 /* Disabled, otherwise every `attach' in an unprivileged user session
1515 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1517 /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1518 be enabled. GetLastError () returns an correct error code, though. */
1519 if (enable
&& GetLastError () == ERROR_NOT_ALL_ASSIGNED
)
1523 ret
= orig_priv
.Privileges
[0].Attributes
== SE_PRIVILEGE_ENABLED
? 1 : 0;
1527 CloseHandle (token_hdl
);
1532 /* Attach to process PID, then initialize for debugging it. */
1534 child_attach (char *args
, int from_tty
)
1540 error_no_arg ("process-id to attach");
1542 if (set_process_privilege (SE_DEBUG_NAME
, TRUE
) < 0)
1544 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1545 printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1548 pid
= strtoul (args
, 0, 0); /* Windows pid */
1550 ok
= DebugActiveProcess (pid
);
1555 /* Try fall back to Cygwin pid */
1556 pid
= cygwin_internal (CW_CYGWIN_PID_TO_WINPID
, pid
);
1559 ok
= DebugActiveProcess (pid
);
1562 error ("Can't attach to process.");
1565 if (has_detach_ability ())
1568 DebugSetProcessKillOnExit (FALSE
);
1573 char *exec_file
= (char *) get_exec_file (0);
1576 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1577 target_pid_to_str (pid_to_ptid (pid
)));
1579 printf_unfiltered ("Attaching to %s\n",
1580 target_pid_to_str (pid_to_ptid (pid
)));
1582 gdb_flush (gdb_stdout
);
1585 do_initial_child_stuff (pid
);
1586 target_terminal_ours ();
1590 child_detach (char *args
, int from_tty
)
1594 if (has_detach_ability ())
1596 delete_command (NULL
, 0);
1597 child_continue (DBG_CONTINUE
, -1);
1598 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1600 error ("Can't detach process %lu (error %lu)",
1601 current_event
.dwProcessId
, GetLastError ());
1604 DebugSetProcessKillOnExit (FALSE
);
1606 if (detached
&& from_tty
)
1608 char *exec_file
= get_exec_file (0);
1611 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1612 current_event
.dwProcessId
);
1613 gdb_flush (gdb_stdout
);
1615 inferior_ptid
= null_ptid
;
1616 unpush_target (&child_ops
);
1619 /* Print status information about what we're accessing. */
1622 child_files_info (struct target_ops
*ignore
)
1624 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1625 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1630 child_open (char *arg
, int from_tty
)
1632 error ("Use the \"run\" command to start a Unix child process.");
1635 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1636 EXEC_FILE is the file to run.
1637 ALLARGS is a string containing the arguments to the program.
1638 ENV is the environment vector to pass. Errors reported with error(). */
1641 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1648 PROCESS_INFORMATION pi
;
1652 char real_path
[MAXPATHLEN
];
1654 char shell
[MAX_PATH
+ 1]; /* Path to shell */
1657 int ostdin
, ostdout
, ostderr
;
1660 error ("No executable specified, use `target exec'.\n");
1662 memset (&si
, 0, sizeof (si
));
1663 si
.cb
= sizeof (si
);
1667 flags
= DEBUG_ONLY_THIS_PROCESS
;
1668 cygwin_conv_to_win32_path (exec_file
, real_path
);
1674 sh
= getenv ("SHELL");
1677 cygwin_conv_to_win32_path (sh
, shell
);
1678 newallargs
= alloca (sizeof (" -c 'exec '") + strlen (exec_file
)
1679 + strlen (allargs
) + 2);
1680 sprintf (newallargs
, " -c 'exec %s %s'", exec_file
, allargs
);
1681 allargs
= newallargs
;
1683 flags
= DEBUG_PROCESS
;
1687 flags
|= CREATE_NEW_PROCESS_GROUP
;
1690 flags
|= CREATE_NEW_CONSOLE
;
1692 args
= alloca (strlen (toexec
) + strlen (allargs
) + 2);
1693 strcpy (args
, toexec
);
1695 strcat (args
, allargs
);
1697 /* Prepare the environment vars for CreateProcess. */
1699 /* This code used to assume all env vars were file names and would
1700 translate them all to win32 style. That obviously doesn't work in the
1701 general case. The current rule is that we only translate PATH.
1702 We need to handle PATH because we're about to call CreateProcess and
1703 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1704 in both posix and win32 environments. cygwin.dll will change it back
1705 to posix style if necessary. */
1707 static const char *conv_path_names
[] =
1713 /* CreateProcess takes the environment list as a null terminated set of
1714 strings (i.e. two nulls terminate the list). */
1716 /* Get total size for env strings. */
1717 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1721 for (j
= 0; conv_path_names
[j
]; j
++)
1723 len
= strlen (conv_path_names
[j
]);
1724 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1726 if (cygwin_posix_path_list_p (env
[i
] + len
))
1728 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1730 envlen
+= strlen (env
[i
]) + 1;
1734 if (conv_path_names
[j
] == NULL
)
1735 envlen
+= strlen (env
[i
]) + 1;
1738 winenv
= alloca (envlen
+ 1);
1740 /* Copy env strings into new buffer. */
1741 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1745 for (j
= 0; conv_path_names
[j
]; j
++)
1747 len
= strlen (conv_path_names
[j
]);
1748 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1750 if (cygwin_posix_path_list_p (env
[i
] + len
))
1752 memcpy (temp
, env
[i
], len
);
1753 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1756 strcpy (temp
, env
[i
]);
1760 if (conv_path_names
[j
] == NULL
)
1761 strcpy (temp
, env
[i
]);
1763 temp
+= strlen (temp
) + 1;
1766 /* Final nil string to terminate new env. */
1770 if (!inferior_io_terminal
)
1771 tty
= ostdin
= ostdout
= ostderr
= -1;
1774 tty
= open (inferior_io_terminal
, O_RDWR
| O_NOCTTY
);
1777 print_sys_errmsg (inferior_io_terminal
, errno
);
1778 ostdin
= ostdout
= ostderr
= -1;
1791 ret
= CreateProcess (0,
1792 args
, /* command line */
1793 NULL
, /* Security */
1795 TRUE
, /* inherit handles */
1796 flags
, /* start flags */
1798 NULL
, /* current directory */
1813 error ("Error creating process %s, (error %d)\n", exec_file
, (unsigned) GetLastError ());
1815 CloseHandle (pi
.hThread
);
1816 CloseHandle (pi
.hProcess
);
1818 if (useshell
&& shell
[0] != '\0')
1823 do_initial_child_stuff (pi
.dwProcessId
);
1825 /* child_continue (DBG_CONTINUE, -1); */
1826 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1830 child_mourn_inferior (void)
1832 (void) child_continue (DBG_CONTINUE
, -1);
1833 i386_cleanup_dregs();
1834 unpush_target (&child_ops
);
1835 generic_mourn_inferior ();
1838 /* Send a SIGINT to the process group. This acts just like the user typed a
1839 ^C on the controlling terminal. */
1844 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1845 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1846 registers_changed (); /* refresh register state */
1850 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1851 int write
, struct mem_attrib
*mem
,
1852 struct target_ops
*target
)
1857 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1858 len
, (DWORD
) memaddr
));
1859 if (!WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1862 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1866 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1867 len
, (DWORD
) memaddr
));
1868 if (!ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
,
1876 child_kill_inferior (void)
1878 CHECK (TerminateProcess (current_process_handle
, 0));
1882 if (!child_continue (DBG_CONTINUE
, -1))
1884 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1886 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1890 CHECK (CloseHandle (current_process_handle
));
1892 /* this may fail in an attached process so don't check. */
1893 (void) CloseHandle (current_thread
->h
);
1894 target_mourn_inferior (); /* or just child_mourn_inferior? */
1898 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1901 DWORD continue_status
= DBG_CONTINUE
;
1903 int pid
= PIDGET (ptid
);
1905 if (sig
!= TARGET_SIGNAL_0
)
1907 if (current_event
.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT
)
1909 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig
));
1911 else if (sig
== last_sig
)
1912 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1915 /* This code does not seem to work, because
1916 the kernel does probably not consider changes in the ExceptionRecord
1917 structure when passing the exception to the inferior.
1918 Note that this seems possible in the exception handler itself. */
1921 for (i
= 0; xlate
[i
].them
!= -1; i
++)
1922 if (xlate
[i
].us
== sig
)
1924 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
=
1926 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
1929 if (continue_status
== DBG_CONTINUE
)
1931 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig
));
1935 DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1939 last_sig
= TARGET_SIGNAL_0
;
1941 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1944 /* Get context for currently selected thread */
1945 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1950 /* Single step by setting t bit */
1951 child_fetch_inferior_registers (PS_REGNUM
);
1952 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1955 if (th
->context
.ContextFlags
)
1957 if (debug_registers_changed
)
1959 th
->context
.Dr0
= dr
[0];
1960 th
->context
.Dr1
= dr
[1];
1961 th
->context
.Dr2
= dr
[2];
1962 th
->context
.Dr3
= dr
[3];
1963 /* th->context.Dr6 = dr[6];
1964 FIXME: should we set dr6 also ?? */
1965 th
->context
.Dr7
= dr
[7];
1967 CHECK (SetThreadContext (th
->h
, &th
->context
));
1968 th
->context
.ContextFlags
= 0;
1972 /* Allow continuing with the same signal that interrupted us.
1973 Otherwise complain. */
1975 child_continue (continue_status
, pid
);
1979 child_prepare_to_store (void)
1981 /* Do nothing, since we can store individual regs */
1985 child_can_run (void)
1993 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1994 PIDGET (inferior_ptid
)));
1997 struct target_ops child_ops
;
2000 init_child_ops (void)
2002 child_ops
.to_shortname
= "child";
2003 child_ops
.to_longname
= "Win32 child process";
2004 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
2005 child_ops
.to_open
= child_open
;
2006 child_ops
.to_close
= child_close
;
2007 child_ops
.to_attach
= child_attach
;
2008 child_ops
.to_detach
= child_detach
;
2009 child_ops
.to_resume
= child_resume
;
2010 child_ops
.to_wait
= child_wait
;
2011 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
2012 child_ops
.to_store_registers
= child_store_inferior_registers
;
2013 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
2014 child_ops
.to_xfer_memory
= child_xfer_memory
;
2015 child_ops
.to_files_info
= child_files_info
;
2016 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2017 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2018 child_ops
.to_terminal_init
= terminal_init_inferior
;
2019 child_ops
.to_terminal_inferior
= terminal_inferior
;
2020 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2021 child_ops
.to_terminal_ours
= terminal_ours
;
2022 child_ops
.to_terminal_save_ours
= terminal_save_ours
;
2023 child_ops
.to_terminal_info
= child_terminal_info
;
2024 child_ops
.to_kill
= child_kill_inferior
;
2025 child_ops
.to_create_inferior
= child_create_inferior
;
2026 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
2027 child_ops
.to_can_run
= child_can_run
;
2028 child_ops
.to_thread_alive
= win32_child_thread_alive
;
2029 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
2030 child_ops
.to_stop
= child_stop
;
2031 child_ops
.to_stratum
= process_stratum
;
2032 child_ops
.to_has_all_memory
= 1;
2033 child_ops
.to_has_memory
= 1;
2034 child_ops
.to_has_stack
= 1;
2035 child_ops
.to_has_registers
= 1;
2036 child_ops
.to_has_execution
= 1;
2037 child_ops
.to_magic
= OPS_MAGIC
;
2041 _initialize_win32_nat (void)
2043 struct cmd_list_element
*c
;
2047 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
2048 "Load dll library symbols from FILE.");
2049 set_cmd_completer (c
, filename_completer
);
2051 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
2053 add_show_from_set (add_set_cmd ("shell", class_support
, var_boolean
,
2055 "Set use of shell to start subprocess.",
2059 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
2060 (char *) &new_console
,
2061 "Set creation of new console when creating child process.",
2065 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
2066 (char *) &new_group
,
2067 "Set creation of new group when creating child process.",
2071 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
2072 (char *) &debug_exec
,
2073 "Set whether to display execution in child process.",
2077 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
2078 (char *) &debug_events
,
2079 "Set whether to display kernel events in child process.",
2083 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
2084 (char *) &debug_memory
,
2085 "Set whether to display memory accesses in child process.",
2089 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
2090 (char *) &debug_exceptions
,
2091 "Set whether to display kernel exceptions in child process.",
2095 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
2096 add_info_alias ("sharedlibrary", "dll", 1);
2098 add_prefix_cmd ("w32", class_info
, info_w32_command
,
2099 "Print information specific to Win32 debugging.",
2100 &info_w32_cmdlist
, "info w32 ", 0, &infolist
);
2102 add_cmd ("selector", class_info
, display_selectors
,
2103 "Display selectors infos.",
2106 add_target (&child_ops
);
2109 /* Hardware watchpoint support, adapted from go32-nat.c code. */
2111 /* Pass the address ADDR to the inferior in the I'th debug register.
2112 Here we just store the address in dr array, the registers will be
2113 actually set up when child_continue is called. */
2115 cygwin_set_dr (int i
, CORE_ADDR addr
)
2118 internal_error (__FILE__
, __LINE__
,
2119 "Invalid register %d in cygwin_set_dr.\n", i
);
2120 dr
[i
] = (unsigned) addr
;
2121 debug_registers_changed
= 1;
2122 debug_registers_used
= 1;
2125 /* Pass the value VAL to the inferior in the DR7 debug control
2126 register. Here we just store the address in D_REGS, the watchpoint
2127 will be actually set up in child_wait. */
2129 cygwin_set_dr7 (unsigned val
)
2132 debug_registers_changed
= 1;
2133 debug_registers_used
= 1;
2136 /* Get the value of the DR6 debug status register from the inferior.
2137 Here we just return the value stored in dr[6]
2138 by the last call to thread_rec for current_event.dwThreadId id. */
2140 cygwin_get_dr6 (void)
2146 /* Determine if the thread referenced by "pid" is alive
2147 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
2148 it means that the pid has died. Otherwise it is assumed to be alive. */
2150 win32_child_thread_alive (ptid_t ptid
)
2152 int pid
= PIDGET (ptid
);
2154 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
2158 /* Convert pid to printable format. */
2160 cygwin_pid_to_str (ptid_t ptid
)
2162 static char buf
[80];
2163 int pid
= PIDGET (ptid
);
2165 if ((DWORD
) pid
== current_event
.dwProcessId
)
2166 sprintf (buf
, "process %d", pid
);
2168 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
2173 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
2175 struct objfile
*objfile
;
2176 char *objfile_basename
;
2177 const char *dll_basename
;
2179 if (!(dll_basename
= strrchr (dll_name
, '/')))
2180 dll_basename
= dll_name
;
2184 ALL_OBJFILES (objfile
)
2186 objfile_basename
= strrchr (objfile
->name
, '/');
2188 if (objfile_basename
&&
2189 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
2191 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2192 base_addr
, dll_name
);
2197 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
2198 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
2206 struct target_ops
*target
;
2208 } map_code_section_args
;
2211 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
2215 struct section_table
*new_target_sect_ptr
;
2217 map_code_section_args
*args
= (map_code_section_args
*) obj
;
2218 struct target_ops
*target
= args
->target
;
2219 if (sect
->flags
& SEC_CODE
)
2221 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
2223 if (target
->to_sections
)
2225 old
= target
->to_sections_end
- target
->to_sections
;
2226 target
->to_sections
= (struct section_table
*)
2227 xrealloc ((char *) target
->to_sections
,
2228 (sizeof (struct section_table
)) * (1 + old
));
2233 target
->to_sections
= (struct section_table
*)
2234 xmalloc ((sizeof (struct section_table
)));
2236 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
2238 /* Update the to_sections field in the core_ops structure
2242 core_ops
.to_sections
= target
->to_sections
;
2243 core_ops
.to_sections_end
= target
->to_sections_end
;
2245 new_target_sect_ptr
= target
->to_sections
+ old
;
2246 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
2247 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
2248 bfd_section_size (abfd
, sect
);;
2249 new_target_sect_ptr
->the_bfd_section
= sect
;
2250 new_target_sect_ptr
->bfd
= abfd
;
2255 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
2258 map_code_section_args map_args
;
2259 asection
*lowest_sect
;
2261 if (dll_name
== NULL
|| target
== NULL
)
2263 name
= xstrdup (dll_name
);
2264 dll_bfd
= bfd_openr (name
, "pei-i386");
2265 if (dll_bfd
== NULL
)
2268 if (bfd_check_format (dll_bfd
, bfd_object
))
2270 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
2271 if (lowest_sect
== NULL
)
2273 map_args
.target
= target
;
2274 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
2276 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
2283 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
2285 struct target_ops
*target
= (struct target_ops
*) obj
;
2290 char *dll_name
= NULL
;
2292 struct win32_pstatus
*pstatus
;
2295 if (strncmp (sect
->name
, ".module", 7))
2298 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
2301 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2304 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
2307 pstatus
= (struct win32_pstatus
*) buf
;
2309 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
2310 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
2311 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
2314 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
2317 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
2320 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
2322 while ((p
= strchr (dll_name
, '\\')))
2325 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
2326 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
2328 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
2329 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
2340 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
2347 child_clear_solibs ();
2348 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
2352 if (solib_end
&& solib_end
->name
)
2353 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
2354 solib_end
->load_addr
);
2359 fetch_elf_core_registers (char *core_reg_sect
,
2360 unsigned core_reg_size
,
2365 if (core_reg_size
< sizeof (CONTEXT
))
2367 error ("Core file register section too small (%u bytes).", core_reg_size
);
2370 for (r
= 0; r
< NUM_REGS
; r
++)
2371 supply_register (r
, core_reg_sect
+ mappings
[r
]);
2374 static struct core_fns win32_elf_core_fns
=
2376 bfd_target_elf_flavour
,
2377 default_check_format
,
2378 default_core_sniffer
,
2379 fetch_elf_core_registers
,
2384 _initialize_core_win32 (void)
2386 add_core_fns (&win32_elf_core_fns
);
2390 _initialize_check_for_gdb_ini (void)
2393 if (inhibit_gdbinit
)
2396 homedir
= getenv ("HOME");
2400 char *oldini
= (char *) alloca (strlen (homedir
) +
2401 sizeof ("/gdb.ini"));
2402 strcpy (oldini
, homedir
);
2403 p
= strchr (oldini
, '\0');
2404 if (p
> oldini
&& p
[-1] != '/')
2406 strcpy (p
, "gdb.ini");
2407 if (access (oldini
, 0) == 0)
2409 int len
= strlen (oldini
);
2410 char *newini
= alloca (len
+ 1);
2411 sprintf (newini
, "%.*s.gdbinit",
2412 (int) (len
- (sizeof ("gdb.ini") - 1)), oldini
);
2413 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);