1 /* Target-vector operations for controlling win32 child processes, for GDB.
3 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free
4 Software Foundation, Inc.
6 Contributed by Cygnus Solutions, A Red Hat Company.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* by Steve Chamberlain, sac@cygnus.com */
27 /* We assume we're being built with and will be used for cygwin. */
30 #include "tm.h" /* required for SSE registers */
31 #include "frame.h" /* required by inferior.h */
36 #include "completer.h"
39 #include "i386-tdep.h"
41 #include <sys/types.h>
46 #include <sys/cygwin.h>
51 #include "gdb_string.h"
52 #include "gdbthread.h"
54 #include <sys/param.h>
57 /* The ui's event loop. */
58 extern int (*ui_loop_hook
) (int signo
);
60 /* If we're not using the old Cygwin header file set, define the
61 following which never should have been in the generic Win32 API
62 headers in the first place since they were our own invention... */
63 #ifndef _GNU_H_WINDOWS_H
66 FLAG_TRACE_BIT
= 0x100,
67 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
70 #include <sys/procfs.h>
74 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_EXTENDED_REGISTERS
76 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER
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 x
86 #define DEBUG_EVENTS(x) if (debug_events) printf x
87 #define DEBUG_MEM(x) if (debug_memory) printf x
88 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf 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 int last_sig
= 0; /* Set if a signal was received from the
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;
128 static int new_console
= 0;
129 static int new_group
= 1;
130 static int debug_exec
= 0; /* show execution */
131 static int debug_events
= 0; /* show events from kernel */
132 static int debug_memory
= 0; /* show target memory accesses */
133 static int debug_exceptions
= 0; /* show target exceptions */
135 /* This vector maps GDB's idea of a register's number into an address
136 in the win32 exception context vector.
138 It also contains the bit mask needed to load the register in question.
140 One day we could read a reg, we could inspect the context we
141 already have loaded, if it doesn't have the bit set that we need,
142 we read that set of registers in using GetThreadContext. If the
143 context already contains what we need, we just unpack it. Then to
144 write a register, first we have to ensure that the context contains
145 the other regs of the group, and then we copy the info in and set
148 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
149 static const int mappings
[] =
151 context_offset (Eax
),
152 context_offset (Ecx
),
153 context_offset (Edx
),
154 context_offset (Ebx
),
155 context_offset (Esp
),
156 context_offset (Ebp
),
157 context_offset (Esi
),
158 context_offset (Edi
),
159 context_offset (Eip
),
160 context_offset (EFlags
),
161 context_offset (SegCs
),
162 context_offset (SegSs
),
163 context_offset (SegDs
),
164 context_offset (SegEs
),
165 context_offset (SegFs
),
166 context_offset (SegGs
),
167 context_offset (FloatSave
.RegisterArea
[0 * 10]),
168 context_offset (FloatSave
.RegisterArea
[1 * 10]),
169 context_offset (FloatSave
.RegisterArea
[2 * 10]),
170 context_offset (FloatSave
.RegisterArea
[3 * 10]),
171 context_offset (FloatSave
.RegisterArea
[4 * 10]),
172 context_offset (FloatSave
.RegisterArea
[5 * 10]),
173 context_offset (FloatSave
.RegisterArea
[6 * 10]),
174 context_offset (FloatSave
.RegisterArea
[7 * 10]),
175 context_offset (FloatSave
.ControlWord
),
176 context_offset (FloatSave
.StatusWord
),
177 context_offset (FloatSave
.TagWord
),
178 context_offset (FloatSave
.ErrorSelector
),
179 context_offset (FloatSave
.ErrorOffset
),
180 context_offset (FloatSave
.DataSelector
),
181 context_offset (FloatSave
.DataOffset
),
182 context_offset (FloatSave
.ErrorSelector
)
185 context_offset (ExtendedRegisters
[10*16]),
186 context_offset (ExtendedRegisters
[11*16]),
187 context_offset (ExtendedRegisters
[12*16]),
188 context_offset (ExtendedRegisters
[13*16]),
189 context_offset (ExtendedRegisters
[14*16]),
190 context_offset (ExtendedRegisters
[15*16]),
191 context_offset (ExtendedRegisters
[16*16]),
192 context_offset (ExtendedRegisters
[17*16]),
194 context_offset (ExtendedRegisters
[24])
198 #undef context_offset
200 /* This vector maps the target's idea of an exception (extracted
201 from the DEBUG_EVENT structure) to GDB's idea. */
203 struct xlate_exception
206 enum target_signal us
;
209 static const struct xlate_exception
212 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
213 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
214 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
215 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
216 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
219 /* Find a thread record given a thread id.
220 If get_context then also retrieve the context for this
223 thread_rec (DWORD id
, int get_context
)
227 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
230 if (!th
->suspend_count
&& get_context
)
232 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
233 th
->suspend_count
= SuspendThread (th
->h
) + 1;
234 else if (get_context
< 0)
235 th
->suspend_count
= -1;
237 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
238 GetThreadContext (th
->h
, &th
->context
);
246 /* Add a thread to the thread list */
248 child_add_thread (DWORD id
, HANDLE h
)
252 if ((th
= thread_rec (id
, FALSE
)))
255 th
= (thread_info
*) xmalloc (sizeof (*th
));
256 memset (th
, 0, sizeof (*th
));
259 th
->next
= thread_head
.next
;
260 thread_head
.next
= th
;
261 add_thread (pid_to_ptid (id
));
265 /* Clear out any old thread list and reintialize it to a
268 child_init_thread_list (void)
270 thread_info
*th
= &thread_head
;
272 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
274 while (th
->next
!= NULL
)
276 thread_info
*here
= th
->next
;
277 th
->next
= here
->next
;
278 (void) CloseHandle (here
->h
);
283 /* Delete a thread from the list of threads */
285 child_delete_thread (DWORD id
)
290 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
291 delete_thread (pid_to_ptid (id
));
293 for (th
= &thread_head
;
294 th
->next
!= NULL
&& th
->next
->id
!= id
;
298 if (th
->next
!= NULL
)
300 thread_info
*here
= th
->next
;
301 th
->next
= here
->next
;
302 CloseHandle (here
->h
);
308 check (BOOL ok
, const char *file
, int line
)
311 printf_filtered ("error return %s:%d was %lu\n", file
, line
, GetLastError ());
315 do_child_fetch_inferior_registers (int r
)
317 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
321 l
= *((long *) context_offset
) & 0xffff;
322 supply_register (r
, (char *) &l
);
324 else if (r
== FOP_REGNUM
)
326 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
327 supply_register (r
, (char *) &l
);
330 supply_register (r
, context_offset
);
333 for (r
= 0; r
< NUM_REGS
; r
++)
334 do_child_fetch_inferior_registers (r
);
339 child_fetch_inferior_registers (int r
)
341 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
342 do_child_fetch_inferior_registers (r
);
346 do_child_store_inferior_registers (int r
)
349 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
352 for (r
= 0; r
< NUM_REGS
; r
++)
353 do_child_store_inferior_registers (r
);
357 /* Store a new register value into the current thread context */
359 child_store_inferior_registers (int r
)
361 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
362 do_child_store_inferior_registers (r
);
365 static int psapi_loaded
= 0;
366 static HMODULE psapi_module_handle
= NULL
;
367 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
368 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
369 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
372 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
378 HMODULE
*DllHandle
= dh_buf
;
383 psapi_EnumProcessModules
== NULL
||
384 psapi_GetModuleInformation
== NULL
||
385 psapi_GetModuleFileNameExA
== NULL
)
390 psapi_module_handle
= LoadLibrary ("psapi.dll");
391 if (!psapi_module_handle
)
393 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
396 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
397 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
398 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
399 "GetModuleFileNameExA");
400 if (psapi_EnumProcessModules
== NULL
||
401 psapi_GetModuleInformation
== NULL
||
402 psapi_GetModuleFileNameExA
== NULL
)
407 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
412 if (!ok
|| !cbNeeded
)
415 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
419 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
426 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
428 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
432 error ("Can't get module info");
434 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
439 error ("Error getting dll name: %u\n", GetLastError ());
441 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
446 dll_name_ret
[0] = '\0';
450 /* Encapsulate the information required in a call to
451 symbol_file_add_args */
452 struct safe_symbol_file_add_args
456 struct section_addr_info
*addrs
;
459 struct ui_file
*err
, *out
;
463 /* Maintain a linked list of "so" information. */
466 struct so_stuff
*next
;
469 struct objfile
*objfile
;
471 } solib_start
, *solib_end
;
473 /* Call symbol_file_add with stderr redirected. We don't care if there
476 safe_symbol_file_add_stub (void *argv
)
478 #define p ((struct safe_symbol_file_add_args *)argv)
479 struct so_stuff
*so
= &solib_start
;
481 while ((so
= so
->next
))
482 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
484 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
489 /* Restore gdb's stderr after calling symbol_file_add */
491 safe_symbol_file_add_cleanup (void *p
)
493 #define sp ((struct safe_symbol_file_add_args *)p)
494 gdb_flush (gdb_stderr
);
495 gdb_flush (gdb_stdout
);
496 ui_file_delete (gdb_stderr
);
497 ui_file_delete (gdb_stdout
);
498 gdb_stderr
= sp
->err
;
499 gdb_stdout
= sp
->out
;
503 /* symbol_file_add wrapper that prevents errors from being displayed. */
504 static struct objfile
*
505 safe_symbol_file_add (char *name
, int from_tty
,
506 struct section_addr_info
*addrs
,
507 int mainline
, int flags
)
509 struct safe_symbol_file_add_args p
;
510 struct cleanup
*cleanup
;
512 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
516 gdb_flush (gdb_stderr
);
517 gdb_flush (gdb_stdout
);
518 gdb_stderr
= ui_file_new ();
519 gdb_stdout
= ui_file_new ();
521 p
.from_tty
= from_tty
;
523 p
.mainline
= mainline
;
525 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
527 do_cleanups (cleanup
);
531 /* Remember the maximum DLL length for printing in info dll command. */
532 int max_dll_name_len
;
535 register_loaded_dll (const char *name
, DWORD load_addr
)
538 char ppath
[MAX_PATH
+ 1];
539 char buf
[MAX_PATH
+ 1];
540 char cwd
[MAX_PATH
+ 1];
542 WIN32_FIND_DATA w32_fd
;
543 HANDLE h
= FindFirstFile(name
, &w32_fd
);
548 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
550 p
= strrchr (buf
, '\\');
553 SetCurrentDirectory (buf
);
554 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
555 SetCurrentDirectory (cwd
);
558 cygwin_conv_to_posix_path (buf
, ppath
);
559 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
561 so
->load_addr
= load_addr
;
564 strcpy (so
->name
, ppath
);
566 solib_end
->next
= so
;
568 len
= strlen (ppath
);
569 if (len
> max_dll_name_len
)
570 max_dll_name_len
= len
;
573 /* Wait for child to do something. Return pid of child, or -1 in case
574 of error; store status through argument pointer OURSTATUS. */
576 handle_load_dll (void *dummy
)
578 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
581 char dll_buf
[MAX_PATH
+ 1];
582 char *dll_name
= NULL
;
585 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
587 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
588 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
592 /* Attempt to read the name of the dll that was detected.
593 This is documented to work only when actively debugging
594 a program. It will not work for attached processes. */
595 if (dll_name
== NULL
|| *dll_name
== '\0')
597 DWORD size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
601 ReadProcessMemory (current_process_handle
,
602 (LPCVOID
) event
->lpImageName
,
603 (char *) &dll_name_ptr
,
604 sizeof (dll_name_ptr
), &done
);
606 /* See if we could read the address of a string, and that the
607 address isn't null. */
609 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
614 ReadProcessMemory (current_process_handle
,
615 (LPCVOID
) (dll_name_ptr
+ len
* size
),
621 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
623 dll_name
= alloca (len
);
627 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
628 ReadProcessMemory (current_process_handle
,
629 (LPCVOID
) dll_name_ptr
,
631 len
* sizeof (WCHAR
),
634 WideCharToMultiByte (CP_ACP
, 0,
635 unicode_dll_name
, len
,
636 dll_name
, len
, 0, 0);
640 ReadProcessMemory (current_process_handle
,
641 (LPCVOID
) dll_name_ptr
,
651 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
657 handle_unload_dll (void *dummy
)
659 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
662 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
663 if (so
->next
->load_addr
== lpBaseOfDll
)
665 struct so_stuff
*sodel
= so
->next
;
666 so
->next
= sodel
->next
;
670 free_objfile (sodel
->objfile
);
674 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
679 /* Return name of last loaded DLL. */
681 child_solib_loaded_library_pathname (int pid
)
683 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
686 /* Clear list of loaded DLLs. */
688 child_clear_solibs (void)
690 struct so_stuff
*so
, *so1
= solib_start
.next
;
692 while ((so
= so1
) != NULL
)
698 solib_start
.next
= NULL
;
699 solib_start
.objfile
= NULL
;
700 solib_end
= &solib_start
;
701 max_dll_name_len
= sizeof ("DLL Name") - 1;
704 /* Add DLL symbol information. */
705 static struct objfile
*
706 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
708 struct section_addr_info section_addrs
;
710 /* The symbols in a dll are offset by 0x1000, which is the
711 the offset from 0 of the first byte in an image - because
712 of the file header and the section alignment. */
714 if (!name
|| !name
[0])
717 memset (§ion_addrs
, 0, sizeof (section_addrs
));
718 section_addrs
.other
[0].name
= ".text";
719 section_addrs
.other
[0].addr
= load_addr
;
720 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
723 /* Load DLL symbol info. */
725 dll_symbol_command (char *args
, int from_tty
)
731 error ("dll-symbols requires a file name");
734 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
736 char *newargs
= (char *) alloca (n
+ 4 + 1);
737 strcpy (newargs
, args
);
738 strcat (newargs
, ".dll");
742 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
745 /* List currently loaded DLLs. */
747 info_dll_command (char *ignore
, int from_tty
)
749 struct so_stuff
*so
= &solib_start
;
754 printf ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
755 while ((so
= so
->next
) != NULL
)
756 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
761 /* Handle DEBUG_STRING output from child process.
762 Cygwin prepends its messages with a "cygwin:". Interpret this as
763 a Cygwin signal. Otherwise just print the string as a warning. */
765 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
770 if (!target_read_string
771 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
775 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
777 if (strncmp (s
, "cYg", 3) != 0)
783 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
784 gotasig
= target_signal_from_host (sig
);
785 ourstatus
->value
.sig
= gotasig
;
787 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
795 handle_exception (struct target_waitstatus
*ourstatus
)
798 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
800 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
802 /* Record the context of the current thread */
803 th
= thread_rec (current_event
.dwThreadId
, -1);
807 case EXCEPTION_ACCESS_VIOLATION
:
808 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
809 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
810 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
813 case STATUS_FLOAT_UNDERFLOW
:
814 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
815 case STATUS_FLOAT_OVERFLOW
:
816 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
817 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
818 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
819 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
822 case STATUS_STACK_OVERFLOW
:
823 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
824 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
825 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
827 case EXCEPTION_BREAKPOINT
:
828 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
829 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
830 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
833 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
834 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
835 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
836 last_sig
= SIGINT
; /* FIXME - should check pass state */
838 case EXCEPTION_SINGLE_STEP
:
839 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
840 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
841 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
843 case EXCEPTION_ILLEGAL_INSTRUCTION
:
844 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
845 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
846 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
850 if (current_event
.u
.Exception
.dwFirstChance
)
852 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
853 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
854 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
855 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
862 /* Resume all artificially suspended threads if we are continuing
865 child_continue (DWORD continue_status
, int id
)
871 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
872 current_event
.dwProcessId
, current_event
.dwThreadId
));
873 res
= ContinueDebugEvent (current_event
.dwProcessId
,
874 current_event
.dwThreadId
,
878 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
879 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
881 for (i
= 0; i
< th
->suspend_count
; i
++)
882 (void) ResumeThread (th
->h
);
883 th
->suspend_count
= 0;
889 /* Get the next event from the child. Return 1 if the event requires
890 handling by WFI (or whatever).
893 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
)
896 DWORD continue_status
, event_code
;
897 thread_info
*th
= NULL
;
898 static thread_info dummy_thread_info
;
903 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
907 continue_status
= DBG_CONTINUE
;
909 event_code
= current_event
.dwDebugEventCode
;
910 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
914 case CREATE_THREAD_DEBUG_EVENT
:
915 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
916 (unsigned) current_event
.dwProcessId
,
917 (unsigned) current_event
.dwThreadId
,
918 "CREATE_THREAD_DEBUG_EVENT"));
919 /* Record the existence of this thread */
920 th
= child_add_thread (current_event
.dwThreadId
,
921 current_event
.u
.CreateThread
.hThread
);
923 printf_unfiltered ("[New %s]\n",
925 pid_to_ptid (current_event
.dwThreadId
)));
926 retval
= current_event
.dwThreadId
;
929 case EXIT_THREAD_DEBUG_EVENT
:
930 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
931 (unsigned) current_event
.dwProcessId
,
932 (unsigned) current_event
.dwThreadId
,
933 "EXIT_THREAD_DEBUG_EVENT"));
934 child_delete_thread (current_event
.dwThreadId
);
935 th
= &dummy_thread_info
;
938 case CREATE_PROCESS_DEBUG_EVENT
:
939 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
940 (unsigned) current_event
.dwProcessId
,
941 (unsigned) current_event
.dwThreadId
,
942 "CREATE_PROCESS_DEBUG_EVENT"));
943 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
944 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
946 main_thread_id
= current_event
.dwThreadId
;
947 /* Add the main thread */
949 th
= child_add_thread (current_event
.dwProcessId
,
950 current_event
.u
.CreateProcessInfo
.hProcess
);
952 th
= child_add_thread (main_thread_id
,
953 current_event
.u
.CreateProcessInfo
.hThread
);
954 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
957 case EXIT_PROCESS_DEBUG_EVENT
:
958 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
959 (unsigned) current_event
.dwProcessId
,
960 (unsigned) current_event
.dwThreadId
,
961 "EXIT_PROCESS_DEBUG_EVENT"));
962 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
963 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
964 CloseHandle (current_process_handle
);
965 retval
= main_thread_id
;
968 case LOAD_DLL_DEBUG_EVENT
:
969 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
970 (unsigned) current_event
.dwProcessId
,
971 (unsigned) current_event
.dwThreadId
,
972 "LOAD_DLL_DEBUG_EVENT"));
973 CloseHandle (current_event
.u
.LoadDll
.hFile
);
974 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
975 registers_changed (); /* mark all regs invalid */
976 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
977 ourstatus
->value
.integer
= 0;
978 retval
= main_thread_id
;
981 case UNLOAD_DLL_DEBUG_EVENT
:
982 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
983 (unsigned) current_event
.dwProcessId
,
984 (unsigned) current_event
.dwThreadId
,
985 "UNLOAD_DLL_DEBUG_EVENT"));
986 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
987 registers_changed (); /* mark all regs invalid */
988 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
989 does not exist yet. */
992 case EXCEPTION_DEBUG_EVENT
:
993 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
994 (unsigned) current_event
.dwProcessId
,
995 (unsigned) current_event
.dwThreadId
,
996 "EXCEPTION_DEBUG_EVENT"));
997 if (handle_exception (ourstatus
))
998 retval
= current_event
.dwThreadId
;
1001 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
1002 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1003 (unsigned) current_event
.dwProcessId
,
1004 (unsigned) current_event
.dwThreadId
,
1005 "OUTPUT_DEBUG_STRING_EVENT"));
1006 if (handle_output_debug_string (ourstatus
))
1007 retval
= main_thread_id
;
1011 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1012 (DWORD
) current_event
.dwProcessId
,
1013 (DWORD
) current_event
.dwThreadId
);
1014 printf_unfiltered (" unknown event code %ld\n",
1015 current_event
.dwDebugEventCode
);
1020 CHECK (child_continue (continue_status
, -1));
1023 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1024 inferior_ptid
= pid_to_ptid (retval
);
1031 /* Wait for interesting events to occur in the target process. */
1033 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1035 int pid
= PIDGET (ptid
);
1037 /* We loop when we get a non-standard exception rather than return
1038 with a SPURIOUS because resume can try and step or modify things,
1039 which needs a current_thread->h. But some of these exceptions mark
1040 the birth or death of threads, which mean that the current thread
1041 isn't necessarily what you think it is. */
1045 int retval
= get_child_debug_event (pid
, ourstatus
);
1047 return pid_to_ptid (retval
);
1052 if (ui_loop_hook
!= NULL
)
1053 detach
= ui_loop_hook (0);
1056 child_kill_inferior ();
1062 do_initial_child_stuff (DWORD pid
)
1064 extern int stop_after_trap
;
1068 exception_count
= 0;
1069 current_event
.dwProcessId
= pid
;
1070 memset (¤t_event
, 0, sizeof (current_event
));
1071 push_target (&child_ops
);
1072 child_init_thread_list ();
1073 child_clear_solibs ();
1074 clear_proceed_status ();
1075 init_wait_for_inferior ();
1077 target_terminal_init ();
1078 target_terminal_inferior ();
1082 stop_after_trap
= 1;
1083 wait_for_inferior ();
1084 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1085 resume (0, stop_signal
);
1089 stop_after_trap
= 0;
1093 /* Since Windows XP, detaching from a process is supported by Windows.
1094 The following code tries loading the appropriate functions dynamically.
1095 If loading these functions succeeds use them to actually detach from
1096 the inferior process, otherwise behave as usual, pretending that
1097 detach has worked. */
1098 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1099 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1102 has_detach_ability ()
1104 static HMODULE kernel32
= NULL
;
1107 kernel32
= LoadLibrary ("kernel32.dll");
1110 if (!DebugSetProcessKillOnExit
)
1111 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1112 "DebugSetProcessKillOnExit");
1113 if (!DebugActiveProcessStop
)
1114 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1115 "DebugActiveProcessStop");
1116 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1122 /* Attach to process PID, then initialize for debugging it. */
1124 child_attach (char *args
, int from_tty
)
1130 error_no_arg ("process-id to attach");
1132 pid
= strtoul (args
, 0, 0);
1133 ok
= DebugActiveProcess (pid
);
1136 error ("Can't attach to process.");
1138 if (has_detach_ability ())
1141 DebugSetProcessKillOnExit (FALSE
);
1146 char *exec_file
= (char *) get_exec_file (0);
1149 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1150 target_pid_to_str (pid_to_ptid (pid
)));
1152 printf_unfiltered ("Attaching to %s\n",
1153 target_pid_to_str (pid_to_ptid (pid
)));
1155 gdb_flush (gdb_stdout
);
1158 do_initial_child_stuff (pid
);
1159 target_terminal_ours ();
1163 child_detach (char *args
, int from_tty
)
1167 if (has_detach_ability ())
1169 delete_command (NULL
, 0);
1170 child_continue (DBG_CONTINUE
, -1);
1171 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1173 error ("Can't detach process %lu (error %lu)",
1174 current_event
.dwProcessId
, GetLastError ());
1177 DebugSetProcessKillOnExit (FALSE
);
1179 if (detached
&& from_tty
)
1181 char *exec_file
= get_exec_file (0);
1184 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1185 current_event
.dwProcessId
);
1186 gdb_flush (gdb_stdout
);
1188 inferior_ptid
= null_ptid
;
1189 unpush_target (&child_ops
);
1192 /* Print status information about what we're accessing. */
1195 child_files_info (struct target_ops
*ignore
)
1197 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1198 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1203 child_open (char *arg
, int from_tty
)
1205 error ("Use the \"run\" command to start a Unix child process.");
1208 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1209 EXEC_FILE is the file to run.
1210 ALLARGS is a string containing the arguments to the program.
1211 ENV is the environment vector to pass. Errors reported with error(). */
1214 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1216 char real_path
[MAXPATHLEN
];
1222 PROCESS_INFORMATION pi
;
1228 error ("No executable specified, use `target exec'.\n");
1230 memset (&si
, 0, sizeof (si
));
1231 si
.cb
= sizeof (si
);
1233 cygwin_conv_to_win32_path (exec_file
, real_path
);
1235 flags
= DEBUG_ONLY_THIS_PROCESS
;
1238 flags
|= CREATE_NEW_PROCESS_GROUP
;
1241 flags
|= CREATE_NEW_CONSOLE
;
1243 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1245 strcpy (args
, real_path
);
1248 strcat (args
, allargs
);
1250 /* Prepare the environment vars for CreateProcess. */
1252 /* This code use to assume all env vars were file names and would
1253 translate them all to win32 style. That obviously doesn't work in the
1254 general case. The current rule is that we only translate PATH.
1255 We need to handle PATH because we're about to call CreateProcess and
1256 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1257 in both posix and win32 environments. cygwin.dll will change it back
1258 to posix style if necessary. */
1260 static const char *conv_path_names
[] =
1266 /* CreateProcess takes the environment list as a null terminated set of
1267 strings (i.e. two nulls terminate the list). */
1269 /* Get total size for env strings. */
1270 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1274 for (j
= 0; conv_path_names
[j
]; j
++)
1276 len
= strlen (conv_path_names
[j
]);
1277 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1279 if (cygwin_posix_path_list_p (env
[i
] + len
))
1281 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1283 envlen
+= strlen (env
[i
]) + 1;
1287 if (conv_path_names
[j
] == NULL
)
1288 envlen
+= strlen (env
[i
]) + 1;
1291 winenv
= alloca (envlen
+ 1);
1293 /* Copy env strings into new buffer. */
1294 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1298 for (j
= 0; conv_path_names
[j
]; j
++)
1300 len
= strlen (conv_path_names
[j
]);
1301 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1303 if (cygwin_posix_path_list_p (env
[i
] + len
))
1305 memcpy (temp
, env
[i
], len
);
1306 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1309 strcpy (temp
, env
[i
]);
1313 if (conv_path_names
[j
] == NULL
)
1314 strcpy (temp
, env
[i
]);
1316 temp
+= strlen (temp
) + 1;
1319 /* Final nil string to terminate new env. */
1323 ret
= CreateProcess (0,
1324 args
, /* command line */
1325 NULL
, /* Security */
1327 TRUE
, /* inherit handles */
1328 flags
, /* start flags */
1330 NULL
, /* current directory */
1334 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1336 CloseHandle (pi
.hThread
);
1337 CloseHandle (pi
.hProcess
);
1338 do_initial_child_stuff (pi
.dwProcessId
);
1340 /* child_continue (DBG_CONTINUE, -1); */
1341 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1345 child_mourn_inferior (void)
1347 (void) child_continue (DBG_CONTINUE
, -1);
1348 unpush_target (&child_ops
);
1349 generic_mourn_inferior ();
1352 /* Send a SIGINT to the process group. This acts just like the user typed a
1353 ^C on the controlling terminal. */
1358 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1359 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1360 registers_changed (); /* refresh register state */
1364 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1365 int write
, struct mem_attrib
*mem
,
1366 struct target_ops
*target
)
1371 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1372 len
, (DWORD
) memaddr
));
1373 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1375 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1379 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1380 len
, (DWORD
) memaddr
));
1381 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1388 child_kill_inferior (void)
1390 CHECK (TerminateProcess (current_process_handle
, 0));
1394 if (!child_continue (DBG_CONTINUE
, -1))
1396 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1398 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1402 CHECK (CloseHandle (current_process_handle
));
1404 /* this may fail in an attached process so don't check. */
1405 (void) CloseHandle (current_thread
->h
);
1406 target_mourn_inferior (); /* or just child_mourn_inferior? */
1410 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1413 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1414 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1415 int pid
= PIDGET (ptid
);
1419 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1422 /* Get context for currently selected thread */
1423 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1428 /* Single step by setting t bit */
1429 child_fetch_inferior_registers (PS_REGNUM
);
1430 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1433 if (th
->context
.ContextFlags
)
1435 CHECK (SetThreadContext (th
->h
, &th
->context
));
1436 th
->context
.ContextFlags
= 0;
1440 /* Allow continuing with the same signal that interrupted us.
1441 Otherwise complain. */
1443 child_continue (continue_status
, pid
);
1447 child_prepare_to_store (void)
1449 /* Do nothing, since we can store individual regs */
1453 child_can_run (void)
1461 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1462 PIDGET (inferior_ptid
)));
1465 struct target_ops child_ops
;
1468 init_child_ops (void)
1470 child_ops
.to_shortname
= "child";
1471 child_ops
.to_longname
= "Win32 child process";
1472 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1473 child_ops
.to_open
= child_open
;
1474 child_ops
.to_close
= child_close
;
1475 child_ops
.to_attach
= child_attach
;
1476 child_ops
.to_detach
= child_detach
;
1477 child_ops
.to_resume
= child_resume
;
1478 child_ops
.to_wait
= child_wait
;
1479 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1480 child_ops
.to_store_registers
= child_store_inferior_registers
;
1481 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1482 child_ops
.to_xfer_memory
= child_xfer_memory
;
1483 child_ops
.to_files_info
= child_files_info
;
1484 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1485 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1486 child_ops
.to_terminal_init
= terminal_init_inferior
;
1487 child_ops
.to_terminal_inferior
= terminal_inferior
;
1488 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1489 child_ops
.to_terminal_ours
= terminal_ours
;
1490 child_ops
.to_terminal_info
= child_terminal_info
;
1491 child_ops
.to_kill
= child_kill_inferior
;
1492 child_ops
.to_load
= 0;
1493 child_ops
.to_lookup_symbol
= 0;
1494 child_ops
.to_create_inferior
= child_create_inferior
;
1495 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1496 child_ops
.to_can_run
= child_can_run
;
1497 child_ops
.to_notice_signals
= 0;
1498 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1499 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1500 child_ops
.to_stop
= child_stop
;
1501 child_ops
.to_stratum
= process_stratum
;
1502 child_ops
.DONT_USE
= 0;
1503 child_ops
.to_has_all_memory
= 1;
1504 child_ops
.to_has_memory
= 1;
1505 child_ops
.to_has_stack
= 1;
1506 child_ops
.to_has_registers
= 1;
1507 child_ops
.to_has_execution
= 1;
1508 child_ops
.to_sections
= 0;
1509 child_ops
.to_sections_end
= 0;
1510 child_ops
.to_magic
= OPS_MAGIC
;
1514 _initialize_inftarg (void)
1516 struct cmd_list_element
*c
;
1520 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1521 "Load dll library symbols from FILE.");
1522 c
->completer
= filename_completer
;
1524 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1526 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1527 (char *) &new_console
,
1528 "Set creation of new console when creating child process.",
1532 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1533 (char *) &new_group
,
1534 "Set creation of new group when creating child process.",
1538 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1539 (char *) &debug_exec
,
1540 "Set whether to display execution in child process.",
1544 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1545 (char *) &debug_events
,
1546 "Set whether to display kernel events in child process.",
1550 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1551 (char *) &debug_memory
,
1552 "Set whether to display memory accesses in child process.",
1556 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1557 (char *) &debug_exceptions
,
1558 "Set whether to display kernel exceptions in child process.",
1562 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1563 add_info_alias ("sharedlibrary", "dll", 1);
1565 add_target (&child_ops
);
1568 /* Determine if the thread referenced by "pid" is alive
1569 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1570 it means that the pid has died. Otherwise it is assumed to be alive. */
1572 win32_child_thread_alive (ptid_t ptid
)
1574 int pid
= PIDGET (ptid
);
1576 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1580 /* Convert pid to printable format. */
1582 cygwin_pid_to_str (ptid_t ptid
)
1584 static char buf
[80];
1585 int pid
= PIDGET (ptid
);
1587 if ((DWORD
) pid
== current_event
.dwProcessId
)
1588 sprintf (buf
, "process %d", pid
);
1590 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1595 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1597 struct objfile
*objfile
;
1598 char *objfile_basename
;
1599 const char *dll_basename
;
1601 if (!(dll_basename
= strrchr (dll_name
, '/')))
1602 dll_basename
= dll_name
;
1606 ALL_OBJFILES (objfile
)
1608 objfile_basename
= strrchr (objfile
->name
, '/');
1610 if (objfile_basename
&&
1611 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1613 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1614 base_addr
, dll_name
);
1619 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1620 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1628 struct target_ops
*target
;
1631 map_code_section_args
;
1634 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1638 struct section_table
*new_target_sect_ptr
;
1640 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1641 struct target_ops
*target
= args
->target
;
1642 if (sect
->flags
& SEC_CODE
)
1644 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1646 if (target
->to_sections
)
1648 old
= target
->to_sections_end
- target
->to_sections
;
1649 target
->to_sections
= (struct section_table
*)
1650 xrealloc ((char *) target
->to_sections
,
1651 (sizeof (struct section_table
)) * (1 + old
));
1656 target
->to_sections
= (struct section_table
*)
1657 xmalloc ((sizeof (struct section_table
)));
1659 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1661 /* Update the to_sections field in the core_ops structure
1665 core_ops
.to_sections
= target
->to_sections
;
1666 core_ops
.to_sections_end
= target
->to_sections_end
;
1668 new_target_sect_ptr
= target
->to_sections
+ old
;
1669 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1670 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1671 bfd_section_size (abfd
, sect
);;
1672 new_target_sect_ptr
->the_bfd_section
= sect
;
1673 new_target_sect_ptr
->bfd
= abfd
;
1678 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1681 map_code_section_args map_args
;
1682 asection
*lowest_sect
;
1684 if (dll_name
== NULL
|| target
== NULL
)
1686 name
= xstrdup (dll_name
);
1687 dll_bfd
= bfd_openr (name
, "pei-i386");
1688 if (dll_bfd
== NULL
)
1691 if (bfd_check_format (dll_bfd
, bfd_object
))
1693 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1694 if (lowest_sect
== NULL
)
1696 map_args
.target
= target
;
1697 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1699 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1706 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1708 struct target_ops
*target
= (struct target_ops
*) obj
;
1713 char *dll_name
= NULL
;
1715 struct win32_pstatus
*pstatus
;
1718 if (strncmp (sect
->name
, ".module", 7))
1721 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1724 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1727 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1730 pstatus
= (struct win32_pstatus
*) buf
;
1732 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1733 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1734 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1737 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1740 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1743 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1745 while ((p
= strchr (dll_name
, '\\')))
1748 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1749 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1751 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1752 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1763 child_solib_add (char *filename
, int from_tty
, struct target_ops
*target
,
1770 child_clear_solibs ();
1771 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1775 if (solib_end
&& solib_end
->name
)
1776 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
1777 solib_end
->load_addr
);
1782 fetch_elf_core_registers (char *core_reg_sect
,
1783 unsigned core_reg_size
,
1788 if (core_reg_size
< sizeof (CONTEXT
))
1790 error ("Core file register section too small (%u bytes).", core_reg_size
);
1793 for (r
= 0; r
< NUM_REGS
; r
++)
1794 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1797 static struct core_fns win32_elf_core_fns
=
1799 bfd_target_elf_flavour
,
1800 default_check_format
,
1801 default_core_sniffer
,
1802 fetch_elf_core_registers
,
1807 _initialize_core_win32 (void)
1809 add_core_fns (&win32_elf_core_fns
);
1813 _initialize_check_for_gdb_ini (void)
1816 if (inhibit_gdbinit
)
1819 homedir
= getenv ("HOME");
1823 char *oldini
= (char *) alloca (strlen (homedir
) +
1824 sizeof ("/gdb.ini"));
1825 strcpy (oldini
, homedir
);
1826 p
= strchr (oldini
, '\0');
1827 if (p
> oldini
&& p
[-1] != '/')
1829 strcpy (p
, "gdb.ini");
1830 if (access (oldini
, 0) == 0)
1832 int len
= strlen (oldini
);
1833 char *newini
= alloca (len
+ 1);
1834 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1835 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);