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 "tm.h" /* required for SSE registers */
29 #include "frame.h" /* required by inferior.h */
34 #include "completer.h"
38 #include <sys/types.h>
43 #include <sys/cygwin.h>
48 #include "gdb_string.h"
49 #include "gdbthread.h"
51 #include <sys/param.h>
54 /* The ui's event loop. */
55 extern int (*ui_loop_hook
) (int signo
);
57 /* If we're not using the old Cygwin header file set, define the
58 following which never should have been in the generic Win32 API
59 headers in the first place since they were our own invention... */
60 #ifndef _GNU_H_WINDOWS_H
63 FLAG_TRACE_BIT
= 0x100,
64 CONTEXT_DEBUGGER
= (CONTEXT_FULL
| CONTEXT_FLOATING_POINT
)
67 #include <sys/procfs.h>
71 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_EXTENDED_REGISTERS
73 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER
77 /* The string sent by cygwin when it processes a signal.
78 FIXME: This should be in a cygwin include file. */
79 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
81 #define CHECK(x) check (x, __FILE__,__LINE__)
82 #define DEBUG_EXEC(x) if (debug_exec) printf x
83 #define DEBUG_EVENTS(x) if (debug_events) printf x
84 #define DEBUG_MEM(x) if (debug_memory) printf x
85 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf x
87 /* Forward declaration */
88 extern struct target_ops child_ops
;
90 static void child_stop (void);
91 static int win32_child_thread_alive (ptid_t
);
92 void child_kill_inferior (void);
94 static int last_sig
= 0; /* Set if a signal was received from the
96 /* Thread information structure used to track information that is
97 not available in gdb's thread structure. */
98 typedef struct thread_info_struct
100 struct thread_info_struct
*next
;
110 static thread_info thread_head
;
112 /* The process and thread handles for the above context. */
114 static DEBUG_EVENT current_event
; /* The current debug event from
116 static HANDLE current_process_handle
; /* Currently executing process */
117 static thread_info
*current_thread
; /* Info on currently selected thread */
118 static DWORD main_thread_id
; /* Thread ID of the main thread */
120 /* Counts of things. */
121 static int exception_count
= 0;
122 static int event_count
= 0;
125 static int new_console
= 0;
126 static int new_group
= 1;
127 static int debug_exec
= 0; /* show execution */
128 static int debug_events
= 0; /* show events from kernel */
129 static int debug_memory
= 0; /* show target memory accesses */
130 static int debug_exceptions
= 0; /* show target exceptions */
132 /* This vector maps GDB's idea of a register's number into an address
133 in the win32 exception context vector.
135 It also contains the bit mask needed to load the register in question.
137 One day we could read a reg, we could inspect the context we
138 already have loaded, if it doesn't have the bit set that we need,
139 we read that set of registers in using GetThreadContext. If the
140 context already contains what we need, we just unpack it. Then to
141 write a register, first we have to ensure that the context contains
142 the other regs of the group, and then we copy the info in and set
145 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
146 static const int mappings
[] =
148 context_offset (Eax
),
149 context_offset (Ecx
),
150 context_offset (Edx
),
151 context_offset (Ebx
),
152 context_offset (Esp
),
153 context_offset (Ebp
),
154 context_offset (Esi
),
155 context_offset (Edi
),
156 context_offset (Eip
),
157 context_offset (EFlags
),
158 context_offset (SegCs
),
159 context_offset (SegSs
),
160 context_offset (SegDs
),
161 context_offset (SegEs
),
162 context_offset (SegFs
),
163 context_offset (SegGs
),
164 context_offset (FloatSave
.RegisterArea
[0 * 10]),
165 context_offset (FloatSave
.RegisterArea
[1 * 10]),
166 context_offset (FloatSave
.RegisterArea
[2 * 10]),
167 context_offset (FloatSave
.RegisterArea
[3 * 10]),
168 context_offset (FloatSave
.RegisterArea
[4 * 10]),
169 context_offset (FloatSave
.RegisterArea
[5 * 10]),
170 context_offset (FloatSave
.RegisterArea
[6 * 10]),
171 context_offset (FloatSave
.RegisterArea
[7 * 10]),
172 context_offset (FloatSave
.ControlWord
),
173 context_offset (FloatSave
.StatusWord
),
174 context_offset (FloatSave
.TagWord
),
175 context_offset (FloatSave
.ErrorSelector
),
176 context_offset (FloatSave
.ErrorOffset
),
177 context_offset (FloatSave
.DataSelector
),
178 context_offset (FloatSave
.DataOffset
),
179 context_offset (FloatSave
.ErrorSelector
)
182 context_offset (ExtendedRegisters
[10*16]),
183 context_offset (ExtendedRegisters
[11*16]),
184 context_offset (ExtendedRegisters
[12*16]),
185 context_offset (ExtendedRegisters
[13*16]),
186 context_offset (ExtendedRegisters
[14*16]),
187 context_offset (ExtendedRegisters
[15*16]),
188 context_offset (ExtendedRegisters
[16*16]),
189 context_offset (ExtendedRegisters
[17*16]),
191 context_offset (ExtendedRegisters
[24])
195 #undef context_offset
197 /* This vector maps the target's idea of an exception (extracted
198 from the DEBUG_EVENT structure) to GDB's idea. */
200 struct xlate_exception
203 enum target_signal us
;
206 static const struct xlate_exception
209 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
210 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
211 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
212 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
213 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
216 /* Find a thread record given a thread id.
217 If get_context then also retrieve the context for this
220 thread_rec (DWORD id
, int get_context
)
224 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
227 if (!th
->suspend_count
&& get_context
)
229 if (get_context
> 0 && id
!= current_event
.dwThreadId
)
230 th
->suspend_count
= SuspendThread (th
->h
) + 1;
231 else if (get_context
< 0)
232 th
->suspend_count
= -1;
234 th
->context
.ContextFlags
= CONTEXT_DEBUGGER_DR
;
235 GetThreadContext (th
->h
, &th
->context
);
243 /* Add a thread to the thread list */
245 child_add_thread (DWORD id
, HANDLE h
)
249 if ((th
= thread_rec (id
, FALSE
)))
252 th
= (thread_info
*) xmalloc (sizeof (*th
));
253 memset (th
, 0, sizeof (*th
));
256 th
->next
= thread_head
.next
;
257 thread_head
.next
= th
;
258 add_thread (pid_to_ptid (id
));
262 /* Clear out any old thread list and reintialize it to a
265 child_init_thread_list (void)
267 thread_info
*th
= &thread_head
;
269 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
271 while (th
->next
!= NULL
)
273 thread_info
*here
= th
->next
;
274 th
->next
= here
->next
;
275 (void) CloseHandle (here
->h
);
280 /* Delete a thread from the list of threads */
282 child_delete_thread (DWORD id
)
287 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id
)));
288 delete_thread (pid_to_ptid (id
));
290 for (th
= &thread_head
;
291 th
->next
!= NULL
&& th
->next
->id
!= id
;
295 if (th
->next
!= NULL
)
297 thread_info
*here
= th
->next
;
298 th
->next
= here
->next
;
299 CloseHandle (here
->h
);
305 check (BOOL ok
, const char *file
, int line
)
308 printf_filtered ("error return %s:%d was %lu\n", file
, line
, GetLastError ());
312 do_child_fetch_inferior_registers (int r
)
314 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
318 l
= *((long *) context_offset
) & 0xffff;
319 supply_register (r
, (char *) &l
);
321 else if (r
== FOP_REGNUM
)
323 l
= (*((long *) context_offset
) >> 16) & ((1 << 11) - 1);
324 supply_register (r
, (char *) &l
);
327 supply_register (r
, context_offset
);
330 for (r
= 0; r
< NUM_REGS
; r
++)
331 do_child_fetch_inferior_registers (r
);
336 child_fetch_inferior_registers (int r
)
338 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
339 do_child_fetch_inferior_registers (r
);
343 do_child_store_inferior_registers (int r
)
346 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
349 for (r
= 0; r
< NUM_REGS
; r
++)
350 do_child_store_inferior_registers (r
);
354 /* Store a new register value into the current thread context */
356 child_store_inferior_registers (int r
)
358 current_thread
= thread_rec (PIDGET (inferior_ptid
), TRUE
);
359 do_child_store_inferior_registers (r
);
362 static int psapi_loaded
= 0;
363 static HMODULE psapi_module_handle
= NULL
;
364 static BOOL
WINAPI (*psapi_EnumProcessModules
) (HANDLE
, HMODULE
*, DWORD
, LPDWORD
) = NULL
;
365 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
) = NULL
;
366 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
) = NULL
;
369 psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
375 HMODULE
*DllHandle
= dh_buf
;
380 psapi_EnumProcessModules
== NULL
||
381 psapi_GetModuleInformation
== NULL
||
382 psapi_GetModuleFileNameExA
== NULL
)
387 psapi_module_handle
= LoadLibrary ("psapi.dll");
388 if (!psapi_module_handle
)
390 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
393 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules");
394 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
395 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
396 "GetModuleFileNameExA");
397 if (psapi_EnumProcessModules
== NULL
||
398 psapi_GetModuleInformation
== NULL
||
399 psapi_GetModuleFileNameExA
== NULL
)
404 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
409 if (!ok
|| !cbNeeded
)
412 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
416 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
423 for (i
= 0; i
< (int) (cbNeeded
/ sizeof (HMODULE
)); i
++)
425 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
429 error ("Can't get module info");
431 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
436 error ("Error getting dll name: %u\n", GetLastError ());
438 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
443 dll_name_ret
[0] = '\0';
447 /* Encapsulate the information required in a call to
448 symbol_file_add_args */
449 struct safe_symbol_file_add_args
453 struct section_addr_info
*addrs
;
456 struct ui_file
*err
, *out
;
460 /* Maintain a linked list of "so" information. */
463 struct so_stuff
*next
;
466 struct objfile
*objfile
;
468 } solib_start
, *solib_end
;
470 /* Call symbol_file_add with stderr redirected. We don't care if there
473 safe_symbol_file_add_stub (void *argv
)
475 #define p ((struct safe_symbol_file_add_args *)argv)
476 struct so_stuff
*so
= &solib_start
;
478 while ((so
= so
->next
))
479 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
481 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
486 /* Restore gdb's stderr after calling symbol_file_add */
488 safe_symbol_file_add_cleanup (void *p
)
490 #define sp ((struct safe_symbol_file_add_args *)p)
491 gdb_flush (gdb_stderr
);
492 gdb_flush (gdb_stdout
);
493 ui_file_delete (gdb_stderr
);
494 ui_file_delete (gdb_stdout
);
495 gdb_stderr
= sp
->err
;
496 gdb_stdout
= sp
->out
;
500 /* symbol_file_add wrapper that prevents errors from being displayed. */
501 static struct objfile
*
502 safe_symbol_file_add (char *name
, int from_tty
,
503 struct section_addr_info
*addrs
,
504 int mainline
, int flags
)
506 struct safe_symbol_file_add_args p
;
507 struct cleanup
*cleanup
;
509 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
513 gdb_flush (gdb_stderr
);
514 gdb_flush (gdb_stdout
);
515 gdb_stderr
= ui_file_new ();
516 gdb_stdout
= ui_file_new ();
518 p
.from_tty
= from_tty
;
520 p
.mainline
= mainline
;
522 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
524 do_cleanups (cleanup
);
528 /* Remember the maximum DLL length for printing in info dll command. */
529 int max_dll_name_len
;
532 register_loaded_dll (const char *name
, DWORD load_addr
)
535 char ppath
[MAX_PATH
+ 1];
536 char buf
[MAX_PATH
+ 1];
537 char cwd
[MAX_PATH
+ 1];
539 WIN32_FIND_DATA w32_fd
;
540 HANDLE h
= FindFirstFile(name
, &w32_fd
);
545 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
547 p
= strrchr (buf
, '\\');
550 SetCurrentDirectory (buf
);
551 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
552 SetCurrentDirectory (cwd
);
555 cygwin_conv_to_posix_path (buf
, ppath
);
556 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
558 so
->load_addr
= load_addr
;
561 strcpy (so
->name
, ppath
);
563 solib_end
->next
= so
;
565 len
= strlen (ppath
);
566 if (len
> max_dll_name_len
)
567 max_dll_name_len
= len
;
570 /* Wait for child to do something. Return pid of child, or -1 in case
571 of error; store status through argument pointer OURSTATUS. */
573 handle_load_dll (void *dummy ATTRIBUTE_UNUSED
)
575 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
578 char dll_buf
[MAX_PATH
+ 1];
579 char *dll_name
= NULL
;
582 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
584 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
585 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
589 /* Attempt to read the name of the dll that was detected.
590 This is documented to work only when actively debugging
591 a program. It will not work for attached processes. */
592 if (dll_name
== NULL
|| *dll_name
== '\0')
594 DWORD size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
598 ReadProcessMemory (current_process_handle
,
599 (LPCVOID
) event
->lpImageName
,
600 (char *) &dll_name_ptr
,
601 sizeof (dll_name_ptr
), &done
);
603 /* See if we could read the address of a string, and that the
604 address isn't null. */
606 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
611 ReadProcessMemory (current_process_handle
,
612 (LPCVOID
) (dll_name_ptr
+ len
* size
),
618 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
620 dll_name
= alloca (len
);
624 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
625 ReadProcessMemory (current_process_handle
,
626 (LPCVOID
) dll_name_ptr
,
628 len
* sizeof (WCHAR
),
631 WideCharToMultiByte (CP_ACP
, 0,
632 unicode_dll_name
, len
,
633 dll_name
, len
, 0, 0);
637 ReadProcessMemory (current_process_handle
,
638 (LPCVOID
) dll_name_ptr
,
648 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
654 handle_unload_dll (void *dummy ATTRIBUTE_UNUSED
)
656 DWORD lpBaseOfDll
= (DWORD
) current_event
.u
.UnloadDll
.lpBaseOfDll
+ 0x1000;
659 for (so
= &solib_start
; so
->next
!= NULL
; so
= so
->next
)
660 if (so
->next
->load_addr
== lpBaseOfDll
)
662 struct so_stuff
*sodel
= so
->next
;
663 so
->next
= sodel
->next
;
667 free_objfile (sodel
->objfile
);
671 error ("Error: dll starting at 0x%lx not found.\n", (DWORD
) lpBaseOfDll
);
676 /* Return name of last loaded DLL. */
678 child_solib_loaded_library_pathname (int pid ATTRIBUTE_UNUSED
)
680 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
683 /* Clear list of loaded DLLs. */
685 child_clear_solibs (void)
687 struct so_stuff
*so
, *so1
= solib_start
.next
;
689 while ((so
= so1
) != NULL
)
695 solib_start
.next
= NULL
;
696 solib_start
.objfile
= NULL
;
697 solib_end
= &solib_start
;
698 max_dll_name_len
= sizeof ("DLL Name") - 1;
701 /* Add DLL symbol information. */
702 static struct objfile
*
703 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
705 struct section_addr_info section_addrs
;
707 /* The symbols in a dll are offset by 0x1000, which is the
708 the offset from 0 of the first byte in an image - because
709 of the file header and the section alignment. */
711 if (!name
|| !name
[0])
714 memset (§ion_addrs
, 0, sizeof (section_addrs
));
715 section_addrs
.other
[0].name
= ".text";
716 section_addrs
.other
[0].addr
= load_addr
;
717 return safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
720 /* Load DLL symbol info. */
722 dll_symbol_command (char *args
, int from_tty
)
728 error ("dll-symbols requires a file name");
731 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
733 char *newargs
= (char *) alloca (n
+ 4 + 1);
734 strcpy (newargs
, args
);
735 strcat (newargs
, ".dll");
739 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
742 /* List currently loaded DLLs. */
744 info_dll_command (char *ignore ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
746 struct so_stuff
*so
= &solib_start
;
751 printf ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
752 while ((so
= so
->next
) != NULL
)
753 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
758 /* Handle DEBUG_STRING output from child process.
759 Cygwin prepends its messages with a "cygwin:". Interpret this as
760 a Cygwin signal. Otherwise just print the string as a warning. */
762 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
767 if (!target_read_string
768 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
772 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
774 if (strncmp (s
, "cYg", 3) != 0)
780 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
781 gotasig
= target_signal_from_host (sig
);
782 ourstatus
->value
.sig
= gotasig
;
784 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
792 handle_exception (struct target_waitstatus
*ourstatus
)
795 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
797 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
799 /* Record the context of the current thread */
800 th
= thread_rec (current_event
.dwThreadId
, -1);
804 case EXCEPTION_ACCESS_VIOLATION
:
805 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
806 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
807 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
810 case STATUS_FLOAT_UNDERFLOW
:
811 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
812 case STATUS_FLOAT_OVERFLOW
:
813 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
814 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
815 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
816 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
819 case STATUS_STACK_OVERFLOW
:
820 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
821 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
822 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
824 case EXCEPTION_BREAKPOINT
:
825 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
826 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
827 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
830 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
831 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
832 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
833 last_sig
= SIGINT
; /* FIXME - should check pass state */
835 case EXCEPTION_SINGLE_STEP
:
836 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
837 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
838 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
840 case EXCEPTION_ILLEGAL_INSTRUCTION
:
841 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
842 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
843 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
847 if (current_event
.u
.Exception
.dwFirstChance
)
849 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
850 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
851 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
852 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
859 /* Resume all artificially suspended threads if we are continuing
862 child_continue (DWORD continue_status
, int id
)
868 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
869 current_event
.dwProcessId
, current_event
.dwThreadId
));
870 res
= ContinueDebugEvent (current_event
.dwProcessId
,
871 current_event
.dwThreadId
,
875 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
876 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
878 for (i
= 0; i
< th
->suspend_count
; i
++)
879 (void) ResumeThread (th
->h
);
880 th
->suspend_count
= 0;
886 /* Get the next event from the child. Return 1 if the event requires
887 handling by WFI (or whatever).
890 get_child_debug_event (int pid ATTRIBUTE_UNUSED
, struct target_waitstatus
*ourstatus
)
893 DWORD continue_status
, event_code
;
894 thread_info
*th
= NULL
;
895 static thread_info dummy_thread_info
;
900 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
904 continue_status
= DBG_CONTINUE
;
906 event_code
= current_event
.dwDebugEventCode
;
907 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
911 case CREATE_THREAD_DEBUG_EVENT
:
912 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
913 (unsigned) current_event
.dwProcessId
,
914 (unsigned) current_event
.dwThreadId
,
915 "CREATE_THREAD_DEBUG_EVENT"));
916 /* Record the existence of this thread */
917 th
= child_add_thread (current_event
.dwThreadId
,
918 current_event
.u
.CreateThread
.hThread
);
920 printf_unfiltered ("[New %s]\n",
922 pid_to_ptid (current_event
.dwThreadId
)));
923 retval
= current_event
.dwThreadId
;
926 case EXIT_THREAD_DEBUG_EVENT
:
927 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
928 (unsigned) current_event
.dwProcessId
,
929 (unsigned) current_event
.dwThreadId
,
930 "EXIT_THREAD_DEBUG_EVENT"));
931 child_delete_thread (current_event
.dwThreadId
);
932 th
= &dummy_thread_info
;
935 case CREATE_PROCESS_DEBUG_EVENT
:
936 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
937 (unsigned) current_event
.dwProcessId
,
938 (unsigned) current_event
.dwThreadId
,
939 "CREATE_PROCESS_DEBUG_EVENT"));
940 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
941 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
943 main_thread_id
= current_event
.dwThreadId
;
944 /* Add the main thread */
946 th
= child_add_thread (current_event
.dwProcessId
,
947 current_event
.u
.CreateProcessInfo
.hProcess
);
949 th
= child_add_thread (main_thread_id
,
950 current_event
.u
.CreateProcessInfo
.hThread
);
951 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
954 case EXIT_PROCESS_DEBUG_EVENT
:
955 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
956 (unsigned) current_event
.dwProcessId
,
957 (unsigned) current_event
.dwThreadId
,
958 "EXIT_PROCESS_DEBUG_EVENT"));
959 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
960 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
961 CloseHandle (current_process_handle
);
962 retval
= main_thread_id
;
965 case LOAD_DLL_DEBUG_EVENT
:
966 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
967 (unsigned) current_event
.dwProcessId
,
968 (unsigned) current_event
.dwThreadId
,
969 "LOAD_DLL_DEBUG_EVENT"));
970 CloseHandle (current_event
.u
.LoadDll
.hFile
);
971 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
972 registers_changed (); /* mark all regs invalid */
973 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
974 ourstatus
->value
.integer
= 0;
975 retval
= main_thread_id
;
978 case UNLOAD_DLL_DEBUG_EVENT
:
979 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
980 (unsigned) current_event
.dwProcessId
,
981 (unsigned) current_event
.dwThreadId
,
982 "UNLOAD_DLL_DEBUG_EVENT"));
983 catch_errors (handle_unload_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
984 registers_changed (); /* mark all regs invalid */
985 /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
986 does not exist yet. */
989 case EXCEPTION_DEBUG_EVENT
:
990 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
991 (unsigned) current_event
.dwProcessId
,
992 (unsigned) current_event
.dwThreadId
,
993 "EXCEPTION_DEBUG_EVENT"));
994 if (handle_exception (ourstatus
))
995 retval
= current_event
.dwThreadId
;
998 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
999 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1000 (unsigned) current_event
.dwProcessId
,
1001 (unsigned) current_event
.dwThreadId
,
1002 "OUTPUT_DEBUG_STRING_EVENT"));
1003 if (handle_output_debug_string (ourstatus
))
1004 retval
= main_thread_id
;
1008 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1009 (DWORD
) current_event
.dwProcessId
,
1010 (DWORD
) current_event
.dwThreadId
);
1011 printf_unfiltered (" unknown event code %ld\n",
1012 current_event
.dwDebugEventCode
);
1017 CHECK (child_continue (continue_status
, -1));
1020 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
1021 inferior_ptid
= pid_to_ptid (retval
);
1028 /* Wait for interesting events to occur in the target process. */
1030 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1032 int pid
= PIDGET (ptid
);
1034 /* We loop when we get a non-standard exception rather than return
1035 with a SPURIOUS because resume can try and step or modify things,
1036 which needs a current_thread->h. But some of these exceptions mark
1037 the birth or death of threads, which mean that the current thread
1038 isn't necessarily what you think it is. */
1042 int retval
= get_child_debug_event (pid
, ourstatus
);
1044 return pid_to_ptid (retval
);
1049 if (ui_loop_hook
!= NULL
)
1050 detach
= ui_loop_hook (0);
1053 child_kill_inferior ();
1059 do_initial_child_stuff (DWORD pid
)
1061 extern int stop_after_trap
;
1065 exception_count
= 0;
1066 current_event
.dwProcessId
= pid
;
1067 memset (¤t_event
, 0, sizeof (current_event
));
1068 push_target (&child_ops
);
1069 child_init_thread_list ();
1070 child_clear_solibs ();
1071 clear_proceed_status ();
1072 init_wait_for_inferior ();
1074 target_terminal_init ();
1075 target_terminal_inferior ();
1079 stop_after_trap
= 1;
1080 wait_for_inferior ();
1081 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1082 resume (0, stop_signal
);
1086 stop_after_trap
= 0;
1090 /* Since Windows XP, detaching from a process is supported by Windows.
1091 The following code tries loading the appropriate functions dynamically.
1092 If loading these functions succeeds use them to actually detach from
1093 the inferior process, otherwise behave as usual, pretending that
1094 detach has worked. */
1095 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1096 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1099 has_detach_ability ()
1101 static HMODULE kernel32
= NULL
;
1104 kernel32
= LoadLibrary ("kernel32.dll");
1107 if (!DebugSetProcessKillOnExit
)
1108 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1109 "DebugSetProcessKillOnExit");
1110 if (!DebugActiveProcessStop
)
1111 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1112 "DebugActiveProcessStop");
1113 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1119 /* Attach to process PID, then initialize for debugging it. */
1121 child_attach (char *args
, int from_tty
)
1127 error_no_arg ("process-id to attach");
1129 pid
= strtoul (args
, 0, 0);
1130 ok
= DebugActiveProcess (pid
);
1133 error ("Can't attach to process.");
1135 if (has_detach_ability ())
1138 DebugSetProcessKillOnExit (FALSE
);
1143 char *exec_file
= (char *) get_exec_file (0);
1146 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1147 target_pid_to_str (pid_to_ptid (pid
)));
1149 printf_unfiltered ("Attaching to %s\n",
1150 target_pid_to_str (pid_to_ptid (pid
)));
1152 gdb_flush (gdb_stdout
);
1155 do_initial_child_stuff (pid
);
1156 target_terminal_ours ();
1160 child_detach (char *args ATTRIBUTE_UNUSED
, int from_tty
)
1164 if (has_detach_ability ())
1166 delete_command (NULL
, 0);
1167 child_continue (DBG_CONTINUE
, -1);
1168 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1170 error ("Can't detach process %lu (error %lu)",
1171 current_event
.dwProcessId
, GetLastError ());
1174 DebugSetProcessKillOnExit (FALSE
);
1176 if (detached
&& from_tty
)
1178 char *exec_file
= get_exec_file (0);
1181 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1182 current_event
.dwProcessId
);
1183 gdb_flush (gdb_stdout
);
1185 inferior_ptid
= null_ptid
;
1186 unpush_target (&child_ops
);
1189 /* Print status information about what we're accessing. */
1192 child_files_info (struct target_ops
*ignore ATTRIBUTE_UNUSED
)
1194 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1195 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1200 child_open (char *arg ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
1202 error ("Use the \"run\" command to start a Unix child process.");
1205 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1206 EXEC_FILE is the file to run.
1207 ALLARGS is a string containing the arguments to the program.
1208 ENV is the environment vector to pass. Errors reported with error(). */
1211 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1213 char real_path
[MAXPATHLEN
];
1219 PROCESS_INFORMATION pi
;
1225 error ("No executable specified, use `target exec'.\n");
1227 memset (&si
, 0, sizeof (si
));
1228 si
.cb
= sizeof (si
);
1230 cygwin_conv_to_win32_path (exec_file
, real_path
);
1232 flags
= DEBUG_ONLY_THIS_PROCESS
;
1235 flags
|= CREATE_NEW_PROCESS_GROUP
;
1238 flags
|= CREATE_NEW_CONSOLE
;
1240 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1242 strcpy (args
, real_path
);
1245 strcat (args
, allargs
);
1247 /* Prepare the environment vars for CreateProcess. */
1249 /* This code use to assume all env vars were file names and would
1250 translate them all to win32 style. That obviously doesn't work in the
1251 general case. The current rule is that we only translate PATH.
1252 We need to handle PATH because we're about to call CreateProcess and
1253 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1254 in both posix and win32 environments. cygwin.dll will change it back
1255 to posix style if necessary. */
1257 static const char *conv_path_names
[] =
1263 /* CreateProcess takes the environment list as a null terminated set of
1264 strings (i.e. two nulls terminate the list). */
1266 /* Get total size for env strings. */
1267 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1271 for (j
= 0; conv_path_names
[j
]; j
++)
1273 len
= strlen (conv_path_names
[j
]);
1274 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1276 if (cygwin_posix_path_list_p (env
[i
] + len
))
1278 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1280 envlen
+= strlen (env
[i
]) + 1;
1284 if (conv_path_names
[j
] == NULL
)
1285 envlen
+= strlen (env
[i
]) + 1;
1288 winenv
= alloca (envlen
+ 1);
1290 /* Copy env strings into new buffer. */
1291 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1295 for (j
= 0; conv_path_names
[j
]; j
++)
1297 len
= strlen (conv_path_names
[j
]);
1298 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1300 if (cygwin_posix_path_list_p (env
[i
] + len
))
1302 memcpy (temp
, env
[i
], len
);
1303 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1306 strcpy (temp
, env
[i
]);
1310 if (conv_path_names
[j
] == NULL
)
1311 strcpy (temp
, env
[i
]);
1313 temp
+= strlen (temp
) + 1;
1316 /* Final nil string to terminate new env. */
1320 ret
= CreateProcess (0,
1321 args
, /* command line */
1322 NULL
, /* Security */
1324 TRUE
, /* inherit handles */
1325 flags
, /* start flags */
1327 NULL
, /* current directory */
1331 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1333 CloseHandle (pi
.hThread
);
1334 CloseHandle (pi
.hProcess
);
1335 do_initial_child_stuff (pi
.dwProcessId
);
1337 /* child_continue (DBG_CONTINUE, -1); */
1338 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1342 child_mourn_inferior (void)
1344 (void) child_continue (DBG_CONTINUE
, -1);
1345 unpush_target (&child_ops
);
1346 generic_mourn_inferior ();
1349 /* Send a SIGINT to the process group. This acts just like the user typed a
1350 ^C on the controlling terminal. */
1355 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1356 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1357 registers_changed (); /* refresh register state */
1361 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1362 int write
, struct mem_attrib
*mem ATTRIBUTE_UNUSED
,
1363 struct target_ops
*target ATTRIBUTE_UNUSED
)
1368 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1369 len
, (DWORD
) memaddr
));
1370 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1372 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1376 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1377 len
, (DWORD
) memaddr
));
1378 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1385 child_kill_inferior (void)
1387 CHECK (TerminateProcess (current_process_handle
, 0));
1391 if (!child_continue (DBG_CONTINUE
, -1))
1393 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1395 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1399 CHECK (CloseHandle (current_process_handle
));
1401 /* this may fail in an attached process so don't check. */
1402 (void) CloseHandle (current_thread
->h
);
1403 target_mourn_inferior (); /* or just child_mourn_inferior? */
1407 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1410 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1411 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1412 int pid
= PIDGET (ptid
);
1416 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1419 /* Get context for currently selected thread */
1420 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1425 /* Single step by setting t bit */
1426 child_fetch_inferior_registers (PS_REGNUM
);
1427 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1430 if (th
->context
.ContextFlags
)
1432 CHECK (SetThreadContext (th
->h
, &th
->context
));
1433 th
->context
.ContextFlags
= 0;
1437 /* Allow continuing with the same signal that interrupted us.
1438 Otherwise complain. */
1440 child_continue (continue_status
, pid
);
1444 child_prepare_to_store (void)
1446 /* Do nothing, since we can store individual regs */
1450 child_can_run (void)
1456 child_close (int x ATTRIBUTE_UNUSED
)
1458 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1459 PIDGET (inferior_ptid
)));
1462 struct target_ops child_ops
;
1465 init_child_ops (void)
1467 child_ops
.to_shortname
= "child";
1468 child_ops
.to_longname
= "Win32 child process";
1469 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1470 child_ops
.to_open
= child_open
;
1471 child_ops
.to_close
= child_close
;
1472 child_ops
.to_attach
= child_attach
;
1473 child_ops
.to_detach
= child_detach
;
1474 child_ops
.to_resume
= child_resume
;
1475 child_ops
.to_wait
= child_wait
;
1476 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1477 child_ops
.to_store_registers
= child_store_inferior_registers
;
1478 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1479 child_ops
.to_xfer_memory
= child_xfer_memory
;
1480 child_ops
.to_files_info
= child_files_info
;
1481 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1482 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1483 child_ops
.to_terminal_init
= terminal_init_inferior
;
1484 child_ops
.to_terminal_inferior
= terminal_inferior
;
1485 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1486 child_ops
.to_terminal_ours
= terminal_ours
;
1487 child_ops
.to_terminal_info
= child_terminal_info
;
1488 child_ops
.to_kill
= child_kill_inferior
;
1489 child_ops
.to_load
= 0;
1490 child_ops
.to_lookup_symbol
= 0;
1491 child_ops
.to_create_inferior
= child_create_inferior
;
1492 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1493 child_ops
.to_can_run
= child_can_run
;
1494 child_ops
.to_notice_signals
= 0;
1495 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1496 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1497 child_ops
.to_stop
= child_stop
;
1498 child_ops
.to_stratum
= process_stratum
;
1499 child_ops
.DONT_USE
= 0;
1500 child_ops
.to_has_all_memory
= 1;
1501 child_ops
.to_has_memory
= 1;
1502 child_ops
.to_has_stack
= 1;
1503 child_ops
.to_has_registers
= 1;
1504 child_ops
.to_has_execution
= 1;
1505 child_ops
.to_sections
= 0;
1506 child_ops
.to_sections_end
= 0;
1507 child_ops
.to_magic
= OPS_MAGIC
;
1511 _initialize_inftarg (void)
1513 struct cmd_list_element
*c
;
1517 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1518 "Load dll library symbols from FILE.");
1519 c
->completer
= filename_completer
;
1521 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1523 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1524 (char *) &new_console
,
1525 "Set creation of new console when creating child process.",
1529 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1530 (char *) &new_group
,
1531 "Set creation of new group when creating child process.",
1535 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1536 (char *) &debug_exec
,
1537 "Set whether to display execution in child process.",
1541 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1542 (char *) &debug_events
,
1543 "Set whether to display kernel events in child process.",
1547 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1548 (char *) &debug_memory
,
1549 "Set whether to display memory accesses in child process.",
1553 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1554 (char *) &debug_exceptions
,
1555 "Set whether to display kernel exceptions in child process.",
1559 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1560 add_info_alias ("sharedlibrary", "dll", 1);
1562 add_target (&child_ops
);
1565 /* Determine if the thread referenced by "pid" is alive
1566 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1567 it means that the pid has died. Otherwise it is assumed to be alive. */
1569 win32_child_thread_alive (ptid_t ptid
)
1571 int pid
= PIDGET (ptid
);
1573 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1577 /* Convert pid to printable format. */
1579 cygwin_pid_to_str (ptid_t ptid
)
1581 static char buf
[80];
1582 int pid
= PIDGET (ptid
);
1584 if ((DWORD
) pid
== current_event
.dwProcessId
)
1585 sprintf (buf
, "process %d", pid
);
1587 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1592 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1594 struct objfile
*objfile
;
1595 char *objfile_basename
;
1596 const char *dll_basename
;
1598 if (!(dll_basename
= strrchr (dll_name
, '/')))
1599 dll_basename
= dll_name
;
1603 ALL_OBJFILES (objfile
)
1605 objfile_basename
= strrchr (objfile
->name
, '/');
1607 if (objfile_basename
&&
1608 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1610 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1611 base_addr
, dll_name
);
1616 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1617 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1625 struct target_ops
*target
;
1628 map_code_section_args
;
1631 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1635 struct section_table
*new_target_sect_ptr
;
1637 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1638 struct target_ops
*target
= args
->target
;
1639 if (sect
->flags
& SEC_CODE
)
1641 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1643 if (target
->to_sections
)
1645 old
= target
->to_sections_end
- target
->to_sections
;
1646 target
->to_sections
= (struct section_table
*)
1647 xrealloc ((char *) target
->to_sections
,
1648 (sizeof (struct section_table
)) * (1 + old
));
1653 target
->to_sections
= (struct section_table
*)
1654 xmalloc ((sizeof (struct section_table
)));
1656 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1658 /* Update the to_sections field in the core_ops structure
1662 core_ops
.to_sections
= target
->to_sections
;
1663 core_ops
.to_sections_end
= target
->to_sections_end
;
1665 new_target_sect_ptr
= target
->to_sections
+ old
;
1666 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1667 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1668 bfd_section_size (abfd
, sect
);;
1669 new_target_sect_ptr
->the_bfd_section
= sect
;
1670 new_target_sect_ptr
->bfd
= abfd
;
1675 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1678 map_code_section_args map_args
;
1679 asection
*lowest_sect
;
1681 if (dll_name
== NULL
|| target
== NULL
)
1683 name
= xstrdup (dll_name
);
1684 dll_bfd
= bfd_openr (name
, "pei-i386");
1685 if (dll_bfd
== NULL
)
1688 if (bfd_check_format (dll_bfd
, bfd_object
))
1690 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1691 if (lowest_sect
== NULL
)
1693 map_args
.target
= target
;
1694 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1696 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1703 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1705 struct target_ops
*target
= (struct target_ops
*) obj
;
1710 char *dll_name
= NULL
;
1712 struct win32_pstatus
*pstatus
;
1715 if (strncmp (sect
->name
, ".module", 7))
1718 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1721 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1724 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1727 pstatus
= (struct win32_pstatus
*) buf
;
1729 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1730 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1731 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1734 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1737 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1740 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1742 while ((p
= strchr (dll_name
, '\\')))
1745 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1746 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1748 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1749 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1760 child_solib_add (char *filename ATTRIBUTE_UNUSED
, int from_tty
, struct target_ops
*target
, int readsyms
)
1766 child_clear_solibs ();
1767 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1771 if (solib_end
&& solib_end
->name
)
1772 solib_end
->objfile
= solib_symbols_add (solib_end
->name
, from_tty
,
1773 solib_end
->load_addr
);
1778 fetch_elf_core_registers (char *core_reg_sect
,
1779 unsigned core_reg_size
,
1784 if (core_reg_size
< sizeof (CONTEXT
))
1786 error ("Core file register section too small (%u bytes).", core_reg_size
);
1789 for (r
= 0; r
< NUM_REGS
; r
++)
1790 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1793 static struct core_fns win32_elf_core_fns
=
1795 bfd_target_elf_flavour
,
1796 default_check_format
,
1797 default_core_sniffer
,
1798 fetch_elf_core_registers
,
1803 _initialize_core_win32 (void)
1805 add_core_fns (&win32_elf_core_fns
);
1809 _initialize_check_for_gdb_ini (void)
1812 if (inhibit_gdbinit
)
1815 homedir
= getenv ("HOME");
1819 char *oldini
= (char *) alloca (strlen (homedir
) +
1820 sizeof ("/gdb.ini"));
1821 strcpy (oldini
, homedir
);
1822 p
= strchr (oldini
, '\0');
1823 if (p
> oldini
&& p
[-1] != '/')
1825 strcpy (p
, "gdb.ini");
1826 if (access (oldini
, 0) == 0)
1828 int len
= strlen (oldini
);
1829 char *newini
= alloca (len
+ 1);
1830 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1831 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);