1 /* Target-vector operations for controlling win32 child processes, for GDB.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Solutions, A Red Hat Company.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* by Steve Chamberlain, sac@cygnus.com */
25 /* We assume we're being built with and will be used for cygwin. */
28 #include "frame.h" /* required by inferior.h */
33 #include "completer.h"
37 #include <sys/types.h>
42 #include <sys/cygwin.h>
47 #include "gdb_string.h"
48 #include "gdbthread.h"
50 #include <sys/param.h>
53 /* The ui's event loop. */
54 extern int (*ui_loop_hook
) (int signo
);
56 /* If we're not using the old Cygwin header file set, define the
57 following which never should have been in the generic Win32 API
58 headers in the first place since they were our own invention... */
59 #ifndef _GNU_H_WINDOWS_H
62 FLAG_TRACE_BIT
= 0x100,
63 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
66 #include <sys/procfs.h>
69 /* The string sent by cygwin when it processes a signal.
70 FIXME: This should be in a cygwin include file. */
71 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
73 #define CHECK(x) check (x, __FILE__,__LINE__)
74 #define DEBUG_EXEC(x) if (debug_exec) printf x
75 #define DEBUG_EVENTS(x) if (debug_events) printf x
76 #define DEBUG_MEM(x) if (debug_memory) printf x
77 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf x
79 /* Forward declaration */
80 extern struct target_ops child_ops
;
82 static void child_stop (void);
83 static int win32_child_thread_alive (ptid_t
);
84 void child_kill_inferior (void);
86 static int last_sig
= 0; /* Set if a signal was received from the
88 /* Thread information structure used to track information that is
89 not available in gdb's thread structure. */
90 typedef struct thread_info_struct
92 struct thread_info_struct
*next
;
102 static thread_info thread_head
;
104 /* The process and thread handles for the above context. */
106 static DEBUG_EVENT current_event
; /* The current debug event from
108 static HANDLE current_process_handle
; /* Currently executing process */
109 static thread_info
*current_thread
; /* Info on currently selected thread */
110 static DWORD main_thread_id
; /* Thread ID of the main thread */
112 /* Counts of things. */
113 static int exception_count
= 0;
114 static int event_count
= 0;
117 static int new_console
= 0;
118 static int new_group
= 1;
119 static int debug_exec
= 0; /* show execution */
120 static int debug_events
= 0; /* show events from kernel */
121 static int debug_memory
= 0; /* show target memory accesses */
122 static int debug_exceptions
= 0; /* show target exceptions */
124 /* This vector maps GDB's idea of a register's number into an address
125 in the win32 exception context vector.
127 It also contains the bit mask needed to load the register in question.
129 One day we could read a reg, we could inspect the context we
130 already have loaded, if it doesn't have the bit set that we need,
131 we read that set of registers in using GetThreadContext. If the
132 context already contains what we need, we just unpack it. Then to
133 write a register, first we have to ensure that the context contains
134 the other regs of the group, and then we copy the info in and set
137 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
138 static const int mappings
[] =
140 context_offset (Eax
),
141 context_offset (Ecx
),
142 context_offset (Edx
),
143 context_offset (Ebx
),
144 context_offset (Esp
),
145 context_offset (Ebp
),
146 context_offset (Esi
),
147 context_offset (Edi
),
148 context_offset (Eip
),
149 context_offset (EFlags
),
150 context_offset (SegCs
),
151 context_offset (SegSs
),
152 context_offset (SegDs
),
153 context_offset (SegEs
),
154 context_offset (SegFs
),
155 context_offset (SegGs
),
156 context_offset (FloatSave
.RegisterArea
[0 * 10]),
157 context_offset (FloatSave
.RegisterArea
[1 * 10]),
158 context_offset (FloatSave
.RegisterArea
[2 * 10]),
159 context_offset (FloatSave
.RegisterArea
[3 * 10]),
160 context_offset (FloatSave
.RegisterArea
[4 * 10]),
161 context_offset (FloatSave
.RegisterArea
[5 * 10]),
162 context_offset (FloatSave
.RegisterArea
[6 * 10]),
163 context_offset (FloatSave
.RegisterArea
[7 * 10]),
164 context_offset (FloatSave
.ControlWord
),
165 context_offset (FloatSave
.StatusWord
),
166 context_offset (FloatSave
.TagWord
),
167 context_offset (FloatSave
.ErrorSelector
),
168 context_offset (FloatSave
.ErrorOffset
),
169 context_offset (FloatSave
.DataSelector
),
170 context_offset (FloatSave
.DataOffset
),
171 context_offset (FloatSave
.ErrorSelector
)
174 #undef context_offset
176 /* This vector maps the target's idea of an exception (extracted
177 from the DEBUG_EVENT structure) to GDB's idea. */
179 struct xlate_exception
182 enum target_signal us
;
185 static const struct xlate_exception
188 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
189 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
190 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
191 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
192 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
195 /* Find a thread record given a thread id.
196 If get_context then also retrieve the context for this
199 thread_rec (DWORD id
, int get_context
)
203 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
206 if (!th
->suspend_count
&& get_context
)
208 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
209 th
->suspend_count
= SuspendThread (th
->h
) + 1;
210 else if (get_context
< 0)
211 th
->suspend_count
= -1;
213 th
->context
.ContextFlags
= CONTEXT_DEBUGGER
;
214 GetThreadContext (th
->h
, &th
->context
);
222 /* Add a thread to the thread list */
224 child_add_thread (DWORD id
, HANDLE h
)
228 if ((th
= thread_rec (id
, FALSE
)))
231 th
= (thread_info
*) xmalloc (sizeof (*th
));
232 memset (th
, 0, sizeof (*th
));
235 th
->next
= thread_head
.next
;
236 thread_head
.next
= th
;
237 add_thread (pid_to_ptid (id
));
241 /* Clear out any old thread list and reintialize it to a
244 child_init_thread_list (void)
246 thread_info
*th
= &thread_head
;
248 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
250 while (th
->next
!= NULL
)
252 thread_info
*here
= th
->next
;
253 th
->next
= here
->next
;
254 (void) CloseHandle (here
->h
);
259 /* Delete a thread from the list of threads */
261 child_delete_thread (DWORD id
)
266 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
267 delete_thread (pid_to_ptid (id
));
269 for (th
= &thread_head
;
270 th
->next
!= NULL
&& th
->next
->id
!= id
;
274 if (th
->next
!= NULL
)
276 thread_info
*here
= th
->next
;
277 th
->next
= here
->next
;
278 CloseHandle (here
->h
);
284 check (BOOL ok
, const char *file
, int line
)
287 printf_filtered ("error return %s:%d was %lu\n", file
, line
, GetLastError ());
291 do_child_fetch_inferior_registers (int r
)
293 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
297 l
= *((long *) context_offset
) & 0xffff;
298 supply_register (r
, (char *) &l
);
300 else if (r
== FOP_REGNUM
)
302 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
303 supply_register (r
, (char *) &l
);
306 supply_register (r
, context_offset
);
309 for (r
= 0; r
< NUM_REGS
; r
++)
310 do_child_fetch_inferior_registers (r
);
315 child_fetch_inferior_registers (int r
)
317 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
318 do_child_fetch_inferior_registers (r
);
322 do_child_store_inferior_registers (int r
)
325 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
328 for (r
= 0; r
< NUM_REGS
; r
++)
329 do_child_store_inferior_registers (r
);
333 /* Store a new register value into the current thread context */
335 child_store_inferior_registers (int r
)
337 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
338 do_child_store_inferior_registers (r
);
341 static int psapi_loaded
= 0;
342 static HMODULE psapi_module_handle
= NULL
;
343 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
344 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
345 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
348 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
354 HMODULE
*DllHandle
= dh_buf
;
359 psapi_EnumProcessModules
== NULL
||
360 psapi_GetModuleInformation
== NULL
||
361 psapi_GetModuleFileNameExA
== NULL
)
366 psapi_module_handle
= LoadLibrary ("psapi.dll");
367 if (!psapi_module_handle
)
369 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
372 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
373 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
374 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
375 "GetModuleFileNameExA");
376 if (psapi_EnumProcessModules
== NULL
||
377 psapi_GetModuleInformation
== NULL
||
378 psapi_GetModuleFileNameExA
== NULL
)
383 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
388 if (!ok
|| !cbNeeded
)
391 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
395 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
402 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
404 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
408 error ("Can't get module info");
410 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
415 error ("Error getting dll name: %u\n", GetLastError ());
417 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
422 dll_name_ret
[0] = '\0';
426 /* Encapsulate the information required in a call to
427 symbol_file_add_args */
428 struct safe_symbol_file_add_args
432 struct section_addr_info
*addrs
;
435 struct ui_file
*err
, *out
;
439 /* Maintain a linked list of "so" information. */
442 struct so_stuff
*next
;
445 struct objfile
*objfile
;
447 } solib_start
, *solib_end
;
449 /* Call symbol_file_add with stderr redirected. We don't care if there
452 safe_symbol_file_add_stub (void *argv
)
454 #define p ((struct safe_symbol_file_add_args *)argv)
455 struct so_stuff
*so
= &solib_start
;
457 while ((so
= so
->next
))
458 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
460 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
465 /* Restore gdb's stderr after calling symbol_file_add */
467 safe_symbol_file_add_cleanup (void *p
)
469 #define sp ((struct safe_symbol_file_add_args *)p)
470 gdb_flush (gdb_stderr
);
471 gdb_flush (gdb_stdout
);
472 ui_file_delete (gdb_stderr
);
473 ui_file_delete (gdb_stdout
);
474 gdb_stderr
= sp
->err
;
475 gdb_stdout
= sp
->out
;
479 /* symbol_file_add wrapper that prevents errors from being displayed. */
480 static struct objfile
*
481 safe_symbol_file_add (char *name
, int from_tty
,
482 struct section_addr_info
*addrs
,
483 int mainline
, int flags
)
485 struct safe_symbol_file_add_args p
;
486 struct cleanup
*cleanup
;
488 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
492 gdb_flush (gdb_stderr
);
493 gdb_flush (gdb_stdout
);
494 gdb_stderr
= ui_file_new ();
495 gdb_stdout
= ui_file_new ();
497 p
.from_tty
= from_tty
;
499 p
.mainline
= mainline
;
501 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
503 do_cleanups (cleanup
);
507 /* Remember the maximum DLL length for printing in info dll command. */
508 int max_dll_name_len
;
511 register_loaded_dll (const char *name
, DWORD load_addr
)
514 char ppath
[MAX_PATH
+ 1];
515 char buf
[MAX_PATH
+ 1];
516 char cwd
[MAX_PATH
+ 1];
518 WIN32_FIND_DATA w32_fd
;
519 HANDLE h
= FindFirstFile(name
, &w32_fd
);
524 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
526 p
= strrchr (buf
, '\\');
529 SetCurrentDirectory (buf
);
530 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
531 SetCurrentDirectory (cwd
);
534 cygwin_conv_to_posix_path (buf
, ppath
);
535 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
537 so
->load_addr
= load_addr
;
540 strcpy (so
->name
, ppath
);
542 solib_end
->next
= so
;
544 len
= strlen (ppath
);
545 if (len
> max_dll_name_len
)
546 max_dll_name_len
= len
;
549 /* Wait for child to do something. Return pid of child, or -1 in case
550 of error; store status through argument pointer OURSTATUS. */
552 handle_load_dll (void *dummy ATTRIBUTE_UNUSED
)
554 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
557 char dll_buf
[MAX_PATH
+ 1];
558 char *dll_name
= NULL
;
561 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
563 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
564 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
568 /* Attempt to read the name of the dll that was detected.
569 This is documented to work only when actively debugging
570 a program. It will not work for attached processes. */
571 if (dll_name
== NULL
|| *dll_name
== '\0')
573 DWORD size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
577 ReadProcessMemory (current_process_handle
,
578 (LPCVOID
) event
->lpImageName
,
579 (char *) &dll_name_ptr
,
580 sizeof (dll_name_ptr
), &done
);
582 /* See if we could read the address of a string, and that the
583 address isn't null. */
585 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
590 ReadProcessMemory (current_process_handle
,
591 (LPCVOID
) (dll_name_ptr
+ len
* size
),
597 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
599 dll_name
= alloca (len
);
603 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
604 ReadProcessMemory (current_process_handle
,
605 (LPCVOID
) dll_name_ptr
,
607 len
* sizeof (WCHAR
),
610 WideCharToMultiByte (CP_ACP
, 0,
611 unicode_dll_name
, len
,
612 dll_name
, len
, 0, 0);
616 ReadProcessMemory (current_process_handle
,
617 (LPCVOID
) dll_name_ptr
,
627 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
633 handle_unload_dll (void *dummy ATTRIBUTE_UNUSED
)
635 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
638 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
639 if (so
->next
->load_addr
== lpBaseOfDll
)
641 struct so_stuff
*sodel
= so
->next
;
642 so
->next
= sodel
->next
;
646 free_objfile (sodel
->objfile
);
650 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
655 /* Return name of last loaded DLL. */
657 child_solib_loaded_library_pathname (int pid ATTRIBUTE_UNUSED
)
659 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
662 /* Clear list of loaded DLLs. */
664 child_clear_solibs (void)
666 struct so_stuff
*so
, *so1
= solib_start
.next
;
668 while ((so
= so1
) != NULL
)
674 solib_start
.next
= NULL
;
675 solib_start
.objfile
= NULL
;
676 solib_end
= &solib_start
;
677 max_dll_name_len
= sizeof ("DLL Name") - 1;
680 /* Add DLL symbol information. */
681 static struct objfile
*
682 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
684 struct section_addr_info section_addrs
;
686 /* The symbols in a dll are offset by 0x1000, which is the
687 the offset from 0 of the first byte in an image - because
688 of the file header and the section alignment. */
690 if (!name
|| !name
[0])
693 memset (§ion_addrs
, 0, sizeof (section_addrs
));
694 section_addrs
.other
[0].name
= ".text";
695 section_addrs
.other
[0].addr
= load_addr
;
696 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
699 /* Load DLL symbol info. */
701 dll_symbol_command (char *args
, int from_tty
)
707 error ("dll-symbols requires a file name");
710 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
712 char *newargs
= (char *) alloca (n
+ 4 + 1);
713 strcpy (newargs
, args
);
714 strcat (newargs
, ".dll");
718 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
721 /* List currently loaded DLLs. */
723 info_dll_command (char *ignore ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
725 struct so_stuff
*so
= &solib_start
;
730 printf ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
731 while ((so
= so
->next
) != NULL
)
732 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
737 /* Handle DEBUG_STRING output from child process.
738 Cygwin prepends its messages with a "cygwin:". Interpret this as
739 a Cygwin signal. Otherwise just print the string as a warning. */
741 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
746 if (!target_read_string
747 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
751 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
753 if (strncmp (s
, "cYg", 3) != 0)
759 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
760 gotasig
= target_signal_from_host (sig
);
761 ourstatus
->value
.sig
= gotasig
;
763 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
771 handle_exception (struct target_waitstatus
*ourstatus
)
774 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
776 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
778 /* Record the context of the current thread */
779 th
= thread_rec (current_event
.dwThreadId
, -1);
783 case EXCEPTION_ACCESS_VIOLATION
:
784 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
785 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
786 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
789 case STATUS_FLOAT_UNDERFLOW
:
790 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
791 case STATUS_FLOAT_OVERFLOW
:
792 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
793 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
794 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
795 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
798 case STATUS_STACK_OVERFLOW
:
799 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
800 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
801 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
803 case EXCEPTION_BREAKPOINT
:
804 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
805 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
806 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
809 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
810 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
811 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
812 last_sig
= SIGINT
; /* FIXME - should check pass state */
814 case EXCEPTION_SINGLE_STEP
:
815 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
816 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
817 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
819 case EXCEPTION_ILLEGAL_INSTRUCTION
:
820 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
821 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
822 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
826 if (current_event
.u
.Exception
.dwFirstChance
)
828 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
829 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
830 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
831 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
838 /* Resume all artificially suspended threads if we are continuing
841 child_continue (DWORD continue_status
, int id
)
847 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
848 current_event
.dwProcessId
, current_event
.dwThreadId
));
849 res
= ContinueDebugEvent (current_event
.dwProcessId
,
850 current_event
.dwThreadId
,
854 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
855 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
857 for (i
= 0; i
< th
->suspend_count
; i
++)
858 (void) ResumeThread (th
->h
);
859 th
->suspend_count
= 0;
865 /* Get the next event from the child. Return 1 if the event requires
866 handling by WFI (or whatever).
869 get_child_debug_event (int pid ATTRIBUTE_UNUSED
, struct target_waitstatus
*ourstatus
)
872 DWORD continue_status
, event_code
;
873 thread_info
*th
= NULL
;
874 static thread_info dummy_thread_info
;
879 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
883 continue_status
= DBG_CONTINUE
;
885 event_code
= current_event
.dwDebugEventCode
;
886 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
890 case CREATE_THREAD_DEBUG_EVENT
:
891 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
892 (unsigned) current_event
.dwProcessId
,
893 (unsigned) current_event
.dwThreadId
,
894 "CREATE_THREAD_DEBUG_EVENT"));
895 /* Record the existence of this thread */
896 th
= child_add_thread (current_event
.dwThreadId
,
897 current_event
.u
.CreateThread
.hThread
);
899 printf_unfiltered ("[New %s]\n",
901 pid_to_ptid (current_event
.dwThreadId
)));
902 retval
= current_event
.dwThreadId
;
905 case EXIT_THREAD_DEBUG_EVENT
:
906 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
907 (unsigned) current_event
.dwProcessId
,
908 (unsigned) current_event
.dwThreadId
,
909 "EXIT_THREAD_DEBUG_EVENT"));
910 child_delete_thread (current_event
.dwThreadId
);
911 th
= &dummy_thread_info
;
914 case CREATE_PROCESS_DEBUG_EVENT
:
915 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
916 (unsigned) current_event
.dwProcessId
,
917 (unsigned) current_event
.dwThreadId
,
918 "CREATE_PROCESS_DEBUG_EVENT"));
919 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
920 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
922 main_thread_id
= current_event
.dwThreadId
;
923 /* Add the main thread */
925 th
= child_add_thread (current_event
.dwProcessId
,
926 current_event
.u
.CreateProcessInfo
.hProcess
);
928 th
= child_add_thread (main_thread_id
,
929 current_event
.u
.CreateProcessInfo
.hThread
);
930 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
933 case EXIT_PROCESS_DEBUG_EVENT
:
934 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
935 (unsigned) current_event
.dwProcessId
,
936 (unsigned) current_event
.dwThreadId
,
937 "EXIT_PROCESS_DEBUG_EVENT"));
938 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
939 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
940 CloseHandle (current_process_handle
);
941 retval
= main_thread_id
;
944 case LOAD_DLL_DEBUG_EVENT
:
945 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
946 (unsigned) current_event
.dwProcessId
,
947 (unsigned) current_event
.dwThreadId
,
948 "LOAD_DLL_DEBUG_EVENT"));
949 CloseHandle (current_event
.u
.LoadDll
.hFile
);
950 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
951 registers_changed (); /* mark all regs invalid */
952 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
953 ourstatus
->value
.integer
= 0;
954 retval
= main_thread_id
;
957 case UNLOAD_DLL_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 "UNLOAD_DLL_DEBUG_EVENT"));
962 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
963 registers_changed (); /* mark all regs invalid */
964 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
965 does not exist yet. */
968 case EXCEPTION_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 "EXCEPTION_DEBUG_EVENT"));
973 if (handle_exception (ourstatus
))
974 retval
= current_event
.dwThreadId
;
977 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
978 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
979 (unsigned) current_event
.dwProcessId
,
980 (unsigned) current_event
.dwThreadId
,
981 "OUTPUT_DEBUG_STRING_EVENT"));
982 if (handle_output_debug_string (ourstatus
))
983 retval
= main_thread_id
;
987 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
988 (DWORD
) current_event
.dwProcessId
,
989 (DWORD
) current_event
.dwThreadId
);
990 printf_unfiltered (" unknown event code %ld\n",
991 current_event
.dwDebugEventCode
);
996 CHECK (child_continue (continue_status
, -1));
999 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1000 inferior_ptid
= pid_to_ptid (retval
);
1007 /* Wait for interesting events to occur in the target process. */
1009 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1011 int pid
= PIDGET (ptid
);
1013 /* We loop when we get a non-standard exception rather than return
1014 with a SPURIOUS because resume can try and step or modify things,
1015 which needs a current_thread->h. But some of these exceptions mark
1016 the birth or death of threads, which mean that the current thread
1017 isn't necessarily what you think it is. */
1021 int retval
= get_child_debug_event (pid
, ourstatus
);
1023 return pid_to_ptid (retval
);
1028 if (ui_loop_hook
!= NULL
)
1029 detach
= ui_loop_hook (0);
1032 child_kill_inferior ();
1038 do_initial_child_stuff (DWORD pid
)
1040 extern int stop_after_trap
;
1044 exception_count
= 0;
1045 current_event
.dwProcessId
= pid
;
1046 memset (¤t_event
, 0, sizeof (current_event
));
1047 push_target (&child_ops
);
1048 child_init_thread_list ();
1049 child_clear_solibs ();
1050 clear_proceed_status ();
1051 init_wait_for_inferior ();
1053 target_terminal_init ();
1054 target_terminal_inferior ();
1058 stop_after_trap
= 1;
1059 wait_for_inferior ();
1060 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1061 resume (0, stop_signal
);
1065 stop_after_trap
= 0;
1069 /* Since Windows XP, detaching from a process is supported by Windows.
1070 The following code tries loading the appropriate functions dynamically.
1071 If loading these functions succeeds use them to actually detach from
1072 the inferior process, otherwise behave as usual, pretending that
1073 detach has worked. */
1074 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1075 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1078 has_detach_ability ()
1080 static HMODULE kernel32
= NULL
;
1083 kernel32
= LoadLibrary ("kernel32.dll");
1086 if (!DebugSetProcessKillOnExit
)
1087 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1088 "DebugSetProcessKillOnExit");
1089 if (!DebugActiveProcessStop
)
1090 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1091 "DebugActiveProcessStop");
1092 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1098 /* Attach to process PID, then initialize for debugging it. */
1100 child_attach (char *args
, int from_tty
)
1106 error_no_arg ("process-id to attach");
1108 pid
= strtoul (args
, 0, 0);
1109 ok
= DebugActiveProcess (pid
);
1112 error ("Can't attach to process.");
1114 if (has_detach_ability ())
1117 DebugSetProcessKillOnExit (FALSE
);
1122 char *exec_file
= (char *) get_exec_file (0);
1125 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1126 target_pid_to_str (pid_to_ptid (pid
)));
1128 printf_unfiltered ("Attaching to %s\n",
1129 target_pid_to_str (pid_to_ptid (pid
)));
1131 gdb_flush (gdb_stdout
);
1134 do_initial_child_stuff (pid
);
1135 target_terminal_ours ();
1139 child_detach (char *args ATTRIBUTE_UNUSED
, int from_tty
)
1143 if (has_detach_ability ())
1145 delete_command (NULL
, 0);
1146 child_continue (DBG_CONTINUE
, -1);
1147 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1149 error ("Can't detach process %lu (error %lu)",
1150 current_event
.dwProcessId
, GetLastError ());
1153 DebugSetProcessKillOnExit (FALSE
);
1155 if (detached
&& from_tty
)
1157 char *exec_file
= get_exec_file (0);
1160 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1161 current_event
.dwProcessId
);
1162 gdb_flush (gdb_stdout
);
1164 inferior_ptid
= null_ptid
;
1165 unpush_target (&child_ops
);
1168 /* Print status information about what we're accessing. */
1171 child_files_info (struct target_ops
*ignore ATTRIBUTE_UNUSED
)
1173 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1174 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1179 child_open (char *arg ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
1181 error ("Use the \"run\" command to start a Unix child process.");
1184 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1185 EXEC_FILE is the file to run.
1186 ALLARGS is a string containing the arguments to the program.
1187 ENV is the environment vector to pass. Errors reported with error(). */
1190 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1192 char real_path
[MAXPATHLEN
];
1198 PROCESS_INFORMATION pi
;
1204 error ("No executable specified, use `target exec'.\n");
1206 memset (&si
, 0, sizeof (si
));
1207 si
.cb
= sizeof (si
);
1209 cygwin_conv_to_win32_path (exec_file
, real_path
);
1211 flags
= DEBUG_ONLY_THIS_PROCESS
;
1214 flags
|= CREATE_NEW_PROCESS_GROUP
;
1217 flags
|= CREATE_NEW_CONSOLE
;
1219 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1221 strcpy (args
, real_path
);
1224 strcat (args
, allargs
);
1226 /* Prepare the environment vars for CreateProcess. */
1228 /* This code use to assume all env vars were file names and would
1229 translate them all to win32 style. That obviously doesn't work in the
1230 general case. The current rule is that we only translate PATH.
1231 We need to handle PATH because we're about to call CreateProcess and
1232 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1233 in both posix and win32 environments. cygwin.dll will change it back
1234 to posix style if necessary. */
1236 static const char *conv_path_names
[] =
1242 /* CreateProcess takes the environment list as a null terminated set of
1243 strings (i.e. two nulls terminate the list). */
1245 /* Get total size for env strings. */
1246 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1250 for (j
= 0; conv_path_names
[j
]; j
++)
1252 len
= strlen (conv_path_names
[j
]);
1253 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1255 if (cygwin_posix_path_list_p (env
[i
] + len
))
1257 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1259 envlen
+= strlen (env
[i
]) + 1;
1263 if (conv_path_names
[j
] == NULL
)
1264 envlen
+= strlen (env
[i
]) + 1;
1267 winenv
= alloca (envlen
+ 1);
1269 /* Copy env strings into new buffer. */
1270 for (temp
= winenv
, 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 memcpy (temp
, env
[i
], len
);
1282 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1285 strcpy (temp
, env
[i
]);
1289 if (conv_path_names
[j
] == NULL
)
1290 strcpy (temp
, env
[i
]);
1292 temp
+= strlen (temp
) + 1;
1295 /* Final nil string to terminate new env. */
1299 ret
= CreateProcess (0,
1300 args
, /* command line */
1301 NULL
, /* Security */
1303 TRUE
, /* inherit handles */
1304 flags
, /* start flags */
1306 NULL
, /* current directory */
1310 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1312 CloseHandle (pi
.hThread
);
1313 CloseHandle (pi
.hProcess
);
1314 do_initial_child_stuff (pi
.dwProcessId
);
1316 /* child_continue (DBG_CONTINUE, -1); */
1317 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1321 child_mourn_inferior (void)
1323 (void) child_continue (DBG_CONTINUE
, -1);
1324 unpush_target (&child_ops
);
1325 generic_mourn_inferior ();
1328 /* Send a SIGINT to the process group. This acts just like the user typed a
1329 ^C on the controlling terminal. */
1334 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1335 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1336 registers_changed (); /* refresh register state */
1340 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1341 int write
, struct mem_attrib
*mem ATTRIBUTE_UNUSED
,
1342 struct target_ops
*target ATTRIBUTE_UNUSED
)
1347 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1348 len
, (DWORD
) memaddr
));
1349 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1351 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1355 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1356 len
, (DWORD
) memaddr
));
1357 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1364 child_kill_inferior (void)
1366 CHECK (TerminateProcess (current_process_handle
, 0));
1370 if (!child_continue (DBG_CONTINUE
, -1))
1372 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1374 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1378 CHECK (CloseHandle (current_process_handle
));
1380 /* this may fail in an attached process so don't check. */
1381 (void) CloseHandle (current_thread
->h
);
1382 target_mourn_inferior (); /* or just child_mourn_inferior? */
1386 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1389 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1390 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1391 int pid
= PIDGET (ptid
);
1395 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1398 /* Get context for currently selected thread */
1399 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1404 /* Single step by setting t bit */
1405 child_fetch_inferior_registers (PS_REGNUM
);
1406 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1409 if (th
->context
.ContextFlags
)
1411 CHECK (SetThreadContext (th
->h
, &th
->context
));
1412 th
->context
.ContextFlags
= 0;
1416 /* Allow continuing with the same signal that interrupted us.
1417 Otherwise complain. */
1419 child_continue (continue_status
, pid
);
1423 child_prepare_to_store (void)
1425 /* Do nothing, since we can store individual regs */
1429 child_can_run (void)
1435 child_close (int x ATTRIBUTE_UNUSED
)
1437 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1438 PIDGET (inferior_ptid
)));
1441 struct target_ops child_ops
;
1444 init_child_ops (void)
1446 child_ops
.to_shortname
= "child";
1447 child_ops
.to_longname
= "Win32 child process";
1448 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1449 child_ops
.to_open
= child_open
;
1450 child_ops
.to_close
= child_close
;
1451 child_ops
.to_attach
= child_attach
;
1452 child_ops
.to_detach
= child_detach
;
1453 child_ops
.to_resume
= child_resume
;
1454 child_ops
.to_wait
= child_wait
;
1455 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1456 child_ops
.to_store_registers
= child_store_inferior_registers
;
1457 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1458 child_ops
.to_xfer_memory
= child_xfer_memory
;
1459 child_ops
.to_files_info
= child_files_info
;
1460 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1461 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1462 child_ops
.to_terminal_init
= terminal_init_inferior
;
1463 child_ops
.to_terminal_inferior
= terminal_inferior
;
1464 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1465 child_ops
.to_terminal_ours
= terminal_ours
;
1466 child_ops
.to_terminal_info
= child_terminal_info
;
1467 child_ops
.to_kill
= child_kill_inferior
;
1468 child_ops
.to_load
= 0;
1469 child_ops
.to_lookup_symbol
= 0;
1470 child_ops
.to_create_inferior
= child_create_inferior
;
1471 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1472 child_ops
.to_can_run
= child_can_run
;
1473 child_ops
.to_notice_signals
= 0;
1474 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1475 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1476 child_ops
.to_stop
= child_stop
;
1477 child_ops
.to_stratum
= process_stratum
;
1478 child_ops
.DONT_USE
= 0;
1479 child_ops
.to_has_all_memory
= 1;
1480 child_ops
.to_has_memory
= 1;
1481 child_ops
.to_has_stack
= 1;
1482 child_ops
.to_has_registers
= 1;
1483 child_ops
.to_has_execution
= 1;
1484 child_ops
.to_sections
= 0;
1485 child_ops
.to_sections_end
= 0;
1486 child_ops
.to_magic
= OPS_MAGIC
;
1490 _initialize_inftarg (void)
1492 struct cmd_list_element
*c
;
1496 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1497 "Load dll library symbols from FILE.");
1498 c
->completer
= filename_completer
;
1500 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1502 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1503 (char *) &new_console
,
1504 "Set creation of new console when creating child process.",
1508 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1509 (char *) &new_group
,
1510 "Set creation of new group when creating child process.",
1514 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1515 (char *) &debug_exec
,
1516 "Set whether to display execution in child process.",
1520 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1521 (char *) &debug_events
,
1522 "Set whether to display kernel events in child process.",
1526 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1527 (char *) &debug_memory
,
1528 "Set whether to display memory accesses in child process.",
1532 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1533 (char *) &debug_exceptions
,
1534 "Set whether to display kernel exceptions in child process.",
1538 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1539 add_info_alias ("sharedlibrary", "dll", 1);
1541 add_target (&child_ops
);
1544 /* Determine if the thread referenced by "pid" is alive
1545 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1546 it means that the pid has died. Otherwise it is assumed to be alive. */
1548 win32_child_thread_alive (ptid_t ptid
)
1550 int pid
= PIDGET (ptid
);
1552 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1556 /* Convert pid to printable format. */
1558 cygwin_pid_to_str (ptid_t ptid
)
1560 static char buf
[80];
1561 int pid
= PIDGET (ptid
);
1563 if ((DWORD
) pid
== current_event
.dwProcessId
)
1564 sprintf (buf
, "process %d", pid
);
1566 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1571 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1573 struct objfile
*objfile
;
1574 char *objfile_basename
;
1575 const char *dll_basename
;
1577 if (!(dll_basename
= strrchr (dll_name
, '/')))
1578 dll_basename
= dll_name
;
1582 ALL_OBJFILES (objfile
)
1584 objfile_basename
= strrchr (objfile
->name
, '/');
1586 if (objfile_basename
&&
1587 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1589 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1590 base_addr
, dll_name
);
1595 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1596 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1604 struct target_ops
*target
;
1607 map_code_section_args
;
1610 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1614 struct section_table
*new_target_sect_ptr
;
1616 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1617 struct target_ops
*target
= args
->target
;
1618 if (sect
->flags
& SEC_CODE
)
1620 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1622 if (target
->to_sections
)
1624 old
= target
->to_sections_end
- target
->to_sections
;
1625 target
->to_sections
= (struct section_table
*)
1626 xrealloc ((char *) target
->to_sections
,
1627 (sizeof (struct section_table
)) * (1 + old
));
1632 target
->to_sections
= (struct section_table
*)
1633 xmalloc ((sizeof (struct section_table
)));
1635 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1637 /* Update the to_sections field in the core_ops structure
1641 core_ops
.to_sections
= target
->to_sections
;
1642 core_ops
.to_sections_end
= target
->to_sections_end
;
1644 new_target_sect_ptr
= target
->to_sections
+ old
;
1645 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1646 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1647 bfd_section_size (abfd
, sect
);;
1648 new_target_sect_ptr
->the_bfd_section
= sect
;
1649 new_target_sect_ptr
->bfd
= abfd
;
1654 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1657 map_code_section_args map_args
;
1658 asection
*lowest_sect
;
1660 if (dll_name
== NULL
|| target
== NULL
)
1662 name
= xstrdup (dll_name
);
1663 dll_bfd
= bfd_openr (name
, "pei-i386");
1664 if (dll_bfd
== NULL
)
1667 if (bfd_check_format (dll_bfd
, bfd_object
))
1669 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1670 if (lowest_sect
== NULL
)
1672 map_args
.target
= target
;
1673 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1675 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1682 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1684 struct target_ops
*target
= (struct target_ops
*) obj
;
1689 char *dll_name
= NULL
;
1691 struct win32_pstatus
*pstatus
;
1694 if (strncmp (sect
->name
, ".module", 7))
1697 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1700 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1703 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1706 pstatus
= (struct win32_pstatus
*) buf
;
1708 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1709 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1710 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1713 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1716 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1719 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1721 while ((p
= strchr (dll_name
, '\\')))
1724 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1725 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1727 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1728 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1739 child_solib_add (char *filename ATTRIBUTE_UNUSED
, int from_tty
, struct target_ops
*target
, int readsyms
)
1745 child_clear_solibs ();
1746 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1750 if (solib_end
&& solib_end
->name
)
1751 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
1752 solib_end
->load_addr
);
1757 fetch_elf_core_registers (char *core_reg_sect
,
1758 unsigned core_reg_size
,
1763 if (core_reg_size
< sizeof (CONTEXT
))
1765 error ("Core file register section too small (%u bytes).", core_reg_size
);
1768 for (r
= 0; r
< NUM_REGS
; r
++)
1769 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1772 static struct core_fns win32_elf_core_fns
=
1774 bfd_target_elf_flavour
,
1775 default_check_format
,
1776 default_core_sniffer
,
1777 fetch_elf_core_registers
,
1782 _initialize_core_win32 (void)
1784 add_core_fns (&win32_elf_core_fns
);
1788 _initialize_check_for_gdb_ini (void)
1791 if (inhibit_gdbinit
)
1794 homedir
= getenv ("HOME");
1798 char *oldini
= (char *) alloca (strlen (homedir
) +
1799 sizeof ("/gdb.ini"));
1800 strcpy (oldini
, homedir
);
1801 p
= strchr (oldini
, '\0');
1802 if (p
> oldini
&& p
[-1] != '/')
1804 strcpy (p
, "gdb.ini");
1805 if (access (oldini
, 0) == 0)
1807 int len
= strlen (oldini
);
1808 char *newini
= alloca (len
+ 1);
1809 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1810 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);