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
, **last
;
446 } solib_start
, *solib_end
;
448 /* Call symbol_file_add with stderr redirected. We don't care if there
451 safe_symbol_file_add_stub (void *argv
)
453 #define p ((struct safe_symbol_file_add_args *)argv)
454 struct so_stuff
*so
= &solib_start
;
456 while ((so
= so
->next
))
457 if (so
->loaded
&& strcasecmp (so
->name
, p
->name
) == 0)
459 p
->ret
= symbol_file_add (p
->name
, p
->from_tty
, p
->addrs
, p
->mainline
, p
->flags
);
464 /* Restore gdb's stderr after calling symbol_file_add */
466 safe_symbol_file_add_cleanup (void *p
)
468 #define sp ((struct safe_symbol_file_add_args *)p)
469 gdb_flush (gdb_stderr
);
470 gdb_flush (gdb_stdout
);
471 /* ui_file_delete (gdb_stderr); */
472 ui_file_delete (gdb_stdout
);
473 /* gdb_stderr = sp->err; */
474 gdb_stdout
= sp
->out
;
478 /* symbol_file_add wrapper that prevents errors from being displayed. */
479 static struct objfile
*
480 safe_symbol_file_add (char *name
, int from_tty
,
481 struct section_addr_info
*addrs
,
482 int mainline
, int flags
)
484 struct safe_symbol_file_add_args p
;
485 struct cleanup
*cleanup
;
487 cleanup
= make_cleanup (safe_symbol_file_add_cleanup
, &p
);
491 gdb_flush (gdb_stderr
);
492 gdb_flush (gdb_stdout
);
493 /* gdb_stderr = ui_file_new (); */
494 gdb_stdout
= ui_file_new ();
496 p
.from_tty
= from_tty
;
498 p
.mainline
= mainline
;
500 catch_errors (safe_symbol_file_add_stub
, &p
, "", RETURN_MASK_ERROR
);
502 do_cleanups (cleanup
);
506 /* Remember the maximum DLL length for printing in info dll command. */
507 int max_dll_name_len
;
510 register_loaded_dll (const char *name
, DWORD load_addr
)
513 char ppath
[MAX_PATH
+ 1];
514 char buf
[MAX_PATH
+ 1];
515 char cwd
[MAX_PATH
+ 1];
517 WIN32_FIND_DATA w32_fd
;
518 HANDLE h
= FindFirstFile(name
, &w32_fd
);
523 if (GetCurrentDirectory (MAX_PATH
+ 1, cwd
))
525 p
= strrchr (buf
, '\\');
528 SetCurrentDirectory (buf
);
529 GetFullPathName (w32_fd
.cFileName
, MAX_PATH
, buf
, &p
);
530 SetCurrentDirectory (cwd
);
533 cygwin_conv_to_posix_path (buf
, ppath
);
534 so
= (struct so_stuff
*) xmalloc (sizeof (struct so_stuff
) + strlen (ppath
) + 8 + 1);
536 so
->load_addr
= load_addr
;
537 strcpy (so
->name
, ppath
);
539 solib_end
->next
= so
;
542 len
= strlen (ppath
);
543 if (len
> max_dll_name_len
)
544 max_dll_name_len
= len
;
547 /* Wait for child to do something. Return pid of child, or -1 in case
548 of error; store status through argument pointer OURSTATUS. */
550 handle_load_dll (void *dummy ATTRIBUTE_UNUSED
)
552 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
555 char dll_buf
[MAX_PATH
+ 1];
556 char *dll_name
= NULL
;
559 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
561 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
562 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
566 /* Attempt to read the name of the dll that was detected.
567 This is documented to work only when actively debugging
568 a program. It will not work for attached processes. */
569 if (dll_name
== NULL
|| *dll_name
== '\0')
571 DWORD size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
575 ReadProcessMemory (current_process_handle
,
576 (LPCVOID
) event
->lpImageName
,
577 (char *) &dll_name_ptr
,
578 sizeof (dll_name_ptr
), &done
);
580 /* See if we could read the address of a string, and that the
581 address isn't null. */
583 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
588 ReadProcessMemory (current_process_handle
,
589 (LPCVOID
) (dll_name_ptr
+ len
* size
),
595 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
597 dll_name
= alloca (len
);
601 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
602 ReadProcessMemory (current_process_handle
,
603 (LPCVOID
) dll_name_ptr
,
605 len
* sizeof (WCHAR
),
608 WideCharToMultiByte (CP_ACP
, 0,
609 unicode_dll_name
, len
,
610 dll_name
, len
, 0, 0);
614 ReadProcessMemory (current_process_handle
,
615 (LPCVOID
) dll_name_ptr
,
625 register_loaded_dll (dll_name
, (DWORD
) event
->lpBaseOfDll
+ 0x1000);
630 /* Return name of last loaded DLL. */
632 child_solib_loaded_library_pathname (int pid ATTRIBUTE_UNUSED
)
634 return !solib_end
|| !solib_end
->name
[0] ? NULL
: solib_end
->name
;
637 /* Clear list of loaded DLLs. */
639 child_clear_solibs (void)
641 struct so_stuff
*so
, *so1
= solib_start
.next
;
643 while ((so
= so1
) != NULL
)
649 solib_start
.next
= NULL
;
650 solib_end
= &solib_start
;
651 max_dll_name_len
= sizeof ("DLL Name") - 1;
654 /* Add DLL symbol information. */
656 solib_symbols_add (char *name
, int from_tty
, CORE_ADDR load_addr
)
658 struct section_addr_info section_addrs
;
660 /* The symbols in a dll are offset by 0x1000, which is the
661 the offset from 0 of the first byte in an image - because
662 of the file header and the section alignment. */
664 if (!name
|| !name
[0])
667 memset (§ion_addrs
, 0, sizeof (section_addrs
));
668 section_addrs
.other
[0].name
= ".text";
669 section_addrs
.other
[0].addr
= load_addr
;
670 safe_symbol_file_add (name
, from_tty
, NULL
, 0, OBJF_SHARED
);
675 /* Load DLL symbol info. */
677 dll_symbol_command (char *args
, int from_tty
)
683 error ("dll-symbols requires a file name");
686 if (n
> 4 && strcasecmp (args
+ n
- 4, ".dll") != 0)
688 char *newargs
= (char *) alloca (n
+ 4 + 1);
689 strcpy (newargs
, args
);
690 strcat (newargs
, ".dll");
694 safe_symbol_file_add (args
, from_tty
, NULL
, 0, OBJF_SHARED
| OBJF_USERLOADED
);
697 /* List currently loaded DLLs. */
699 info_dll_command (char *ignore ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
701 struct so_stuff
*so
= &solib_start
;
706 printf ("%*s Load Address\n", -max_dll_name_len
, "DLL Name");
707 while ((so
= so
->next
) != NULL
)
708 printf_filtered ("%*s %08lx\n", -max_dll_name_len
, so
->name
, so
->load_addr
);
713 /* Handle DEBUG_STRING output from child process.
714 Cygwin prepends its messages with a "cygwin:". Interpret this as
715 a Cygwin signal. Otherwise just print the string as a warning. */
717 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
722 if (!target_read_string
723 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
727 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
729 if (strncmp (s
, "cYg", 3) != 0)
735 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
736 gotasig
= target_signal_from_host (sig
);
737 ourstatus
->value
.sig
= gotasig
;
739 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
747 handle_exception (struct target_waitstatus
*ourstatus
)
750 DWORD code
= current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
;
752 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
754 /* Record the context of the current thread */
755 th
= thread_rec (current_event
.dwThreadId
, -1);
759 case EXCEPTION_ACCESS_VIOLATION
:
760 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08lx\n",
761 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
762 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
765 case STATUS_FLOAT_UNDERFLOW
:
766 case STATUS_FLOAT_DIVIDE_BY_ZERO
:
767 case STATUS_FLOAT_OVERFLOW
:
768 case STATUS_INTEGER_DIVIDE_BY_ZERO
:
769 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
770 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
771 ourstatus
->value
.sig
= TARGET_SIGNAL_FPE
;
774 case STATUS_STACK_OVERFLOW
:
775 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08lx\n",
776 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
777 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
779 case EXCEPTION_BREAKPOINT
:
780 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08lx\n",
781 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
782 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
785 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08lx\n",
786 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
787 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
788 last_sig
= SIGINT
; /* FIXME - should check pass state */
790 case EXCEPTION_SINGLE_STEP
:
791 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08lx\n",
792 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
793 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
795 case EXCEPTION_ILLEGAL_INSTRUCTION
:
796 DEBUG_EXCEPT (("gdb: Target exception SINGLE_ILL at 0x%08lx\n",
797 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
798 ourstatus
->value
.sig
= TARGET_SIGNAL_ILL
;
802 if (current_event
.u
.Exception
.dwFirstChance
)
804 printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
805 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
806 (DWORD
) current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
807 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
814 /* Resume all artificially suspended threads if we are continuing
817 child_continue (DWORD continue_status
, int id
)
823 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, DBG_CONTINUE);\n",
824 current_event
.dwProcessId
, current_event
.dwThreadId
));
825 res
= ContinueDebugEvent (current_event
.dwProcessId
,
826 current_event
.dwThreadId
,
830 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
831 if (((id
== -1) || (id
== (int) th
->id
)) && th
->suspend_count
)
833 for (i
= 0; i
< th
->suspend_count
; i
++)
834 (void) ResumeThread (th
->h
);
835 th
->suspend_count
= 0;
841 /* Get the next event from the child. Return 1 if the event requires
842 handling by WFI (or whatever).
845 get_child_debug_event (int pid ATTRIBUTE_UNUSED
, struct target_waitstatus
*ourstatus
)
848 DWORD continue_status
, event_code
;
849 thread_info
*th
= NULL
;
850 static thread_info dummy_thread_info
;
855 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 1000)))
859 continue_status
= DBG_CONTINUE
;
861 event_code
= current_event
.dwDebugEventCode
;
862 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
866 case CREATE_THREAD_DEBUG_EVENT
:
867 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
868 (unsigned) current_event
.dwProcessId
,
869 (unsigned) current_event
.dwThreadId
,
870 "CREATE_THREAD_DEBUG_EVENT"));
871 /* Record the existence of this thread */
872 th
= child_add_thread (current_event
.dwThreadId
,
873 current_event
.u
.CreateThread
.hThread
);
875 printf_unfiltered ("[New %s]\n",
877 pid_to_ptid (current_event
.dwThreadId
)));
878 retval
= current_event
.dwThreadId
;
881 case EXIT_THREAD_DEBUG_EVENT
:
882 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
883 (unsigned) current_event
.dwProcessId
,
884 (unsigned) current_event
.dwThreadId
,
885 "EXIT_THREAD_DEBUG_EVENT"));
886 child_delete_thread (current_event
.dwThreadId
);
887 th
= &dummy_thread_info
;
890 case CREATE_PROCESS_DEBUG_EVENT
:
891 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
892 (unsigned) current_event
.dwProcessId
,
893 (unsigned) current_event
.dwThreadId
,
894 "CREATE_PROCESS_DEBUG_EVENT"));
895 CloseHandle (current_event
.u
.CreateProcessInfo
.hFile
);
896 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
898 main_thread_id
= current_event
.dwThreadId
;
899 /* Add the main thread */
901 th
= child_add_thread (current_event
.dwProcessId
,
902 current_event
.u
.CreateProcessInfo
.hProcess
);
904 th
= child_add_thread (main_thread_id
,
905 current_event
.u
.CreateProcessInfo
.hThread
);
906 retval
= ourstatus
->value
.related_pid
= current_event
.dwThreadId
;
909 case EXIT_PROCESS_DEBUG_EVENT
:
910 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
911 (unsigned) current_event
.dwProcessId
,
912 (unsigned) current_event
.dwThreadId
,
913 "EXIT_PROCESS_DEBUG_EVENT"));
914 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
915 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
916 CloseHandle (current_process_handle
);
917 retval
= main_thread_id
;
920 case LOAD_DLL_DEBUG_EVENT
:
921 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
922 (unsigned) current_event
.dwProcessId
,
923 (unsigned) current_event
.dwThreadId
,
924 "LOAD_DLL_DEBUG_EVENT"));
925 CloseHandle (current_event
.u
.LoadDll
.hFile
);
926 catch_errors (handle_load_dll
, NULL
, (char *) "", RETURN_MASK_ALL
);
927 registers_changed (); /* mark all regs invalid */
928 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
929 ourstatus
->value
.integer
= 0;
930 retval
= main_thread_id
;
933 case UNLOAD_DLL_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 "UNLOAD_DLL_DEBUG_EVENT"));
938 break; /* FIXME: don't know what to do here */
940 case EXCEPTION_DEBUG_EVENT
:
941 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
942 (unsigned) current_event
.dwProcessId
,
943 (unsigned) current_event
.dwThreadId
,
944 "EXCEPTION_DEBUG_EVENT"));
945 if (handle_exception (ourstatus
))
946 retval
= current_event
.dwThreadId
;
949 case OUTPUT_DEBUG_STRING_EVENT
: /* message from the kernel */
950 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
951 (unsigned) current_event
.dwProcessId
,
952 (unsigned) current_event
.dwThreadId
,
953 "OUTPUT_DEBUG_STRING_EVENT"));
954 if (handle_output_debug_string (ourstatus
))
955 retval
= main_thread_id
;
959 printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
960 (DWORD
) current_event
.dwProcessId
,
961 (DWORD
) current_event
.dwThreadId
);
962 printf_unfiltered (" unknown event code %ld\n",
963 current_event
.dwDebugEventCode
);
968 CHECK (child_continue (continue_status
, -1));
971 current_thread
= th
? : thread_rec (current_event
.dwThreadId
, TRUE
);
972 inferior_ptid
= pid_to_ptid (retval
);
979 /* Wait for interesting events to occur in the target process. */
981 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
983 int pid
= PIDGET (ptid
);
985 /* We loop when we get a non-standard exception rather than return
986 with a SPURIOUS because resume can try and step or modify things,
987 which needs a current_thread->h. But some of these exceptions mark
988 the birth or death of threads, which mean that the current thread
989 isn't necessarily what you think it is. */
993 int retval
= get_child_debug_event (pid
, ourstatus
);
995 return pid_to_ptid (retval
);
1000 if (ui_loop_hook
!= NULL
)
1001 detach
= ui_loop_hook (0);
1004 child_kill_inferior ();
1010 do_initial_child_stuff (DWORD pid
)
1012 extern int stop_after_trap
;
1016 exception_count
= 0;
1017 current_event
.dwProcessId
= pid
;
1018 memset (¤t_event
, 0, sizeof (current_event
));
1019 push_target (&child_ops
);
1020 child_init_thread_list ();
1021 child_clear_solibs ();
1022 clear_proceed_status ();
1023 init_wait_for_inferior ();
1025 target_terminal_init ();
1026 target_terminal_inferior ();
1030 stop_after_trap
= 1;
1031 wait_for_inferior ();
1032 if (stop_signal
!= TARGET_SIGNAL_TRAP
)
1033 resume (0, stop_signal
);
1037 stop_after_trap
= 0;
1041 /* Since Windows XP, detaching from a process is supported by Windows.
1042 The following code tries loading the appropriate functions dynamically.
1043 If loading these functions succeeds use them to actually detach from
1044 the inferior process, otherwise behave as usual, pretending that
1045 detach has worked. */
1046 static BOOL
WINAPI (*DebugSetProcessKillOnExit
)(BOOL
);
1047 static BOOL
WINAPI (*DebugActiveProcessStop
)(DWORD
);
1050 has_detach_ability ()
1052 static HMODULE kernel32
= NULL
;
1055 kernel32
= LoadLibrary ("kernel32.dll");
1058 if (!DebugSetProcessKillOnExit
)
1059 DebugSetProcessKillOnExit
= GetProcAddress (kernel32
,
1060 "DebugSetProcessKillOnExit");
1061 if (!DebugActiveProcessStop
)
1062 DebugActiveProcessStop
= GetProcAddress (kernel32
,
1063 "DebugActiveProcessStop");
1064 if (DebugSetProcessKillOnExit
&& DebugActiveProcessStop
)
1070 /* Attach to process PID, then initialize for debugging it. */
1072 child_attach (char *args
, int from_tty
)
1078 error_no_arg ("process-id to attach");
1080 pid
= strtoul (args
, 0, 0);
1081 ok
= DebugActiveProcess (pid
);
1084 error ("Can't attach to process.");
1086 if (has_detach_ability ())
1089 DebugSetProcessKillOnExit (FALSE
);
1094 char *exec_file
= (char *) get_exec_file (0);
1097 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
1098 target_pid_to_str (pid_to_ptid (pid
)));
1100 printf_unfiltered ("Attaching to %s\n",
1101 target_pid_to_str (pid_to_ptid (pid
)));
1103 gdb_flush (gdb_stdout
);
1106 do_initial_child_stuff (pid
);
1107 target_terminal_ours ();
1111 child_detach (char *args ATTRIBUTE_UNUSED
, int from_tty
)
1115 if (has_detach_ability ())
1117 delete_command (NULL
, 0);
1118 child_continue (DBG_CONTINUE
, -1);
1119 if (!DebugActiveProcessStop (current_event
.dwProcessId
))
1121 error ("Can't detach process %lu (error %lu)",
1122 current_event
.dwProcessId
, GetLastError ());
1125 DebugSetProcessKillOnExit (FALSE
);
1127 if (detached
&& from_tty
)
1129 char *exec_file
= get_exec_file (0);
1132 printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file
,
1133 current_event
.dwProcessId
);
1134 gdb_flush (gdb_stdout
);
1136 inferior_ptid
= null_ptid
;
1137 unpush_target (&child_ops
);
1140 /* Print status information about what we're accessing. */
1143 child_files_info (struct target_ops
*ignore ATTRIBUTE_UNUSED
)
1145 printf_unfiltered ("\tUsing the running image of %s %s.\n",
1146 attach_flag
? "attached" : "child", target_pid_to_str (inferior_ptid
));
1151 child_open (char *arg ATTRIBUTE_UNUSED
, int from_tty ATTRIBUTE_UNUSED
)
1153 error ("Use the \"run\" command to start a Unix child process.");
1156 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1157 EXEC_FILE is the file to run.
1158 ALLARGS is a string containing the arguments to the program.
1159 ENV is the environment vector to pass. Errors reported with error(). */
1162 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
1164 char real_path
[MAXPATHLEN
];
1170 PROCESS_INFORMATION pi
;
1176 error ("No executable specified, use `target exec'.\n");
1178 memset (&si
, 0, sizeof (si
));
1179 si
.cb
= sizeof (si
);
1181 cygwin_conv_to_win32_path (exec_file
, real_path
);
1183 flags
= DEBUG_ONLY_THIS_PROCESS
;
1186 flags
|= CREATE_NEW_PROCESS_GROUP
;
1189 flags
|= CREATE_NEW_CONSOLE
;
1191 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
1193 strcpy (args
, real_path
);
1196 strcat (args
, allargs
);
1198 /* Prepare the environment vars for CreateProcess. */
1200 /* This code use to assume all env vars were file names and would
1201 translate them all to win32 style. That obviously doesn't work in the
1202 general case. The current rule is that we only translate PATH.
1203 We need to handle PATH because we're about to call CreateProcess and
1204 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
1205 in both posix and win32 environments. cygwin.dll will change it back
1206 to posix style if necessary. */
1208 static const char *conv_path_names
[] =
1214 /* CreateProcess takes the environment list as a null terminated set of
1215 strings (i.e. two nulls terminate the list). */
1217 /* Get total size for env strings. */
1218 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
1222 for (j
= 0; conv_path_names
[j
]; j
++)
1224 len
= strlen (conv_path_names
[j
]);
1225 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1227 if (cygwin_posix_path_list_p (env
[i
] + len
))
1229 + cygwin_posix_to_win32_path_list_buf_size (env
[i
] + len
);
1231 envlen
+= strlen (env
[i
]) + 1;
1235 if (conv_path_names
[j
] == NULL
)
1236 envlen
+= strlen (env
[i
]) + 1;
1239 winenv
= alloca (envlen
+ 1);
1241 /* Copy env strings into new buffer. */
1242 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
1246 for (j
= 0; conv_path_names
[j
]; j
++)
1248 len
= strlen (conv_path_names
[j
]);
1249 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
1251 if (cygwin_posix_path_list_p (env
[i
] + len
))
1253 memcpy (temp
, env
[i
], len
);
1254 cygwin_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
1257 strcpy (temp
, env
[i
]);
1261 if (conv_path_names
[j
] == NULL
)
1262 strcpy (temp
, env
[i
]);
1264 temp
+= strlen (temp
) + 1;
1267 /* Final nil string to terminate new env. */
1271 ret
= CreateProcess (0,
1272 args
, /* command line */
1273 NULL
, /* Security */
1275 TRUE
, /* inherit handles */
1276 flags
, /* start flags */
1278 NULL
, /* current directory */
1282 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1284 CloseHandle (pi
.hThread
);
1285 CloseHandle (pi
.hProcess
);
1286 do_initial_child_stuff (pi
.dwProcessId
);
1288 /* child_continue (DBG_CONTINUE, -1); */
1289 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1293 child_mourn_inferior (void)
1295 (void) child_continue (DBG_CONTINUE
, -1);
1296 unpush_target (&child_ops
);
1297 generic_mourn_inferior ();
1300 /* Send a SIGINT to the process group. This acts just like the user typed a
1301 ^C on the controlling terminal. */
1306 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1307 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1308 registers_changed (); /* refresh register state */
1312 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1313 int write
, struct mem_attrib
*mem ATTRIBUTE_UNUSED
,
1314 struct target_ops
*target ATTRIBUTE_UNUSED
)
1319 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1320 len
, (DWORD
) memaddr
));
1321 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1323 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1327 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1328 len
, (DWORD
) memaddr
));
1329 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1336 child_kill_inferior (void)
1338 CHECK (TerminateProcess (current_process_handle
, 0));
1342 if (!child_continue (DBG_CONTINUE
, -1))
1344 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1346 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1350 CHECK (CloseHandle (current_process_handle
));
1352 /* this may fail in an attached process so don't check. */
1353 (void) CloseHandle (current_thread
->h
);
1354 target_mourn_inferior (); /* or just child_mourn_inferior? */
1358 child_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1361 DWORD continue_status
= last_sig
> 0 && last_sig
< NSIG
?
1362 DBG_EXCEPTION_NOT_HANDLED
: DBG_CONTINUE
;
1363 int pid
= PIDGET (ptid
);
1367 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1370 /* Get context for currently selected thread */
1371 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1376 /* Single step by setting t bit */
1377 child_fetch_inferior_registers (PS_REGNUM
);
1378 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1381 if (th
->context
.ContextFlags
)
1383 CHECK (SetThreadContext (th
->h
, &th
->context
));
1384 th
->context
.ContextFlags
= 0;
1388 /* Allow continuing with the same signal that interrupted us.
1389 Otherwise complain. */
1391 child_continue (continue_status
, pid
);
1395 child_prepare_to_store (void)
1397 /* Do nothing, since we can store individual regs */
1401 child_can_run (void)
1407 child_close (int x ATTRIBUTE_UNUSED
)
1409 DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
1410 PIDGET (inferior_ptid
)));
1413 struct target_ops child_ops
;
1416 init_child_ops (void)
1418 child_ops
.to_shortname
= "child";
1419 child_ops
.to_longname
= "Win32 child process";
1420 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1421 child_ops
.to_open
= child_open
;
1422 child_ops
.to_close
= child_close
;
1423 child_ops
.to_attach
= child_attach
;
1424 child_ops
.to_detach
= child_detach
;
1425 child_ops
.to_resume
= child_resume
;
1426 child_ops
.to_wait
= child_wait
;
1427 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1428 child_ops
.to_store_registers
= child_store_inferior_registers
;
1429 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1430 child_ops
.to_xfer_memory
= child_xfer_memory
;
1431 child_ops
.to_files_info
= child_files_info
;
1432 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1433 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1434 child_ops
.to_terminal_init
= terminal_init_inferior
;
1435 child_ops
.to_terminal_inferior
= terminal_inferior
;
1436 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1437 child_ops
.to_terminal_ours
= terminal_ours
;
1438 child_ops
.to_terminal_info
= child_terminal_info
;
1439 child_ops
.to_kill
= child_kill_inferior
;
1440 child_ops
.to_load
= 0;
1441 child_ops
.to_lookup_symbol
= 0;
1442 child_ops
.to_create_inferior
= child_create_inferior
;
1443 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1444 child_ops
.to_can_run
= child_can_run
;
1445 child_ops
.to_notice_signals
= 0;
1446 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1447 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1448 child_ops
.to_stop
= child_stop
;
1449 child_ops
.to_stratum
= process_stratum
;
1450 child_ops
.DONT_USE
= 0;
1451 child_ops
.to_has_all_memory
= 1;
1452 child_ops
.to_has_memory
= 1;
1453 child_ops
.to_has_stack
= 1;
1454 child_ops
.to_has_registers
= 1;
1455 child_ops
.to_has_execution
= 1;
1456 child_ops
.to_sections
= 0;
1457 child_ops
.to_sections_end
= 0;
1458 child_ops
.to_magic
= OPS_MAGIC
;
1462 _initialize_inftarg (void)
1464 struct cmd_list_element
*c
;
1468 c
= add_com ("dll-symbols", class_files
, dll_symbol_command
,
1469 "Load dll library symbols from FILE.");
1470 c
->completer
= filename_completer
;
1472 add_com_alias ("sharedlibrary", "dll-symbols", class_alias
, 1);
1474 add_show_from_set (add_set_cmd ("new-console", class_support
, var_boolean
,
1475 (char *) &new_console
,
1476 "Set creation of new console when creating child process.",
1480 add_show_from_set (add_set_cmd ("new-group", class_support
, var_boolean
,
1481 (char *) &new_group
,
1482 "Set creation of new group when creating child process.",
1486 add_show_from_set (add_set_cmd ("debugexec", class_support
, var_boolean
,
1487 (char *) &debug_exec
,
1488 "Set whether to display execution in child process.",
1492 add_show_from_set (add_set_cmd ("debugevents", class_support
, var_boolean
,
1493 (char *) &debug_events
,
1494 "Set whether to display kernel events in child process.",
1498 add_show_from_set (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1499 (char *) &debug_memory
,
1500 "Set whether to display memory accesses in child process.",
1504 add_show_from_set (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1505 (char *) &debug_exceptions
,
1506 "Set whether to display kernel exceptions in child process.",
1510 add_info ("dll", info_dll_command
, "Status of loaded DLLs.");
1511 add_info_alias ("sharedlibrary", "dll", 1);
1513 add_target (&child_ops
);
1516 /* Determine if the thread referenced by "pid" is alive
1517 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1518 it means that the pid has died. Otherwise it is assumed to be alive. */
1520 win32_child_thread_alive (ptid_t ptid
)
1522 int pid
= PIDGET (ptid
);
1524 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1528 /* Convert pid to printable format. */
1530 cygwin_pid_to_str (ptid_t ptid
)
1532 static char buf
[80];
1533 int pid
= PIDGET (ptid
);
1535 if ((DWORD
) pid
== current_event
.dwProcessId
)
1536 sprintf (buf
, "process %d", pid
);
1538 sprintf (buf
, "thread %ld.0x%x", current_event
.dwProcessId
, pid
);
1543 core_dll_symbols_add (char *dll_name
, DWORD base_addr
)
1545 struct objfile
*objfile
;
1546 char *objfile_basename
;
1547 const char *dll_basename
;
1549 if (!(dll_basename
= strrchr (dll_name
, '/')))
1550 dll_basename
= dll_name
;
1554 ALL_OBJFILES (objfile
)
1556 objfile_basename
= strrchr (objfile
->name
, '/');
1558 if (objfile_basename
&&
1559 strcmp (dll_basename
, objfile_basename
+ 1) == 0)
1561 printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
1562 base_addr
, dll_name
);
1567 register_loaded_dll (dll_name
, base_addr
+ 0x1000);
1568 solib_symbols_add (dll_name
, 0, (CORE_ADDR
) base_addr
+ 0x1000);
1576 struct target_ops
*target
;
1579 map_code_section_args
;
1582 map_single_dll_code_section (bfd
* abfd
, asection
* sect
, void *obj
)
1586 struct section_table
*new_target_sect_ptr
;
1588 map_code_section_args
*args
= (map_code_section_args
*) obj
;
1589 struct target_ops
*target
= args
->target
;
1590 if (sect
->flags
& SEC_CODE
)
1592 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1594 if (target
->to_sections
)
1596 old
= target
->to_sections_end
- target
->to_sections
;
1597 target
->to_sections
= (struct section_table
*)
1598 xrealloc ((char *) target
->to_sections
,
1599 (sizeof (struct section_table
)) * (1 + old
));
1604 target
->to_sections
= (struct section_table
*)
1605 xmalloc ((sizeof (struct section_table
)));
1607 target
->to_sections_end
= target
->to_sections
+ (1 + old
);
1609 /* Update the to_sections field in the core_ops structure
1613 core_ops
.to_sections
= target
->to_sections
;
1614 core_ops
.to_sections_end
= target
->to_sections_end
;
1616 new_target_sect_ptr
= target
->to_sections
+ old
;
1617 new_target_sect_ptr
->addr
= args
->addr
+ bfd_section_vma (abfd
, sect
);
1618 new_target_sect_ptr
->endaddr
= args
->addr
+ bfd_section_vma (abfd
, sect
) +
1619 bfd_section_size (abfd
, sect
);;
1620 new_target_sect_ptr
->the_bfd_section
= sect
;
1621 new_target_sect_ptr
->bfd
= abfd
;
1626 dll_code_sections_add (const char *dll_name
, int base_addr
, struct target_ops
*target
)
1629 map_code_section_args map_args
;
1630 asection
*lowest_sect
;
1632 if (dll_name
== NULL
|| target
== NULL
)
1634 name
= xstrdup (dll_name
);
1635 dll_bfd
= bfd_openr (name
, "pei-i386");
1636 if (dll_bfd
== NULL
)
1639 if (bfd_check_format (dll_bfd
, bfd_object
))
1641 lowest_sect
= bfd_get_section_by_name (dll_bfd
, ".text");
1642 if (lowest_sect
== NULL
)
1644 map_args
.target
= target
;
1645 map_args
.addr
= base_addr
- bfd_section_vma (dll_bfd
, lowest_sect
);
1647 bfd_map_over_sections (dll_bfd
, &map_single_dll_code_section
, (void *) (&map_args
));
1654 core_section_load_dll_symbols (bfd
* abfd
, asection
* sect
, void *obj
)
1656 struct target_ops
*target
= (struct target_ops
*) obj
;
1661 char *dll_name
= NULL
;
1663 struct win32_pstatus
*pstatus
;
1666 if (strncmp (sect
->name
, ".module", 7))
1669 buf
= (char *) xmalloc (sect
->_raw_size
+ 1);
1672 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1675 if (!bfd_get_section_contents (abfd
, sect
, buf
, 0, sect
->_raw_size
))
1678 pstatus
= (struct win32_pstatus
*) buf
;
1680 memmove (&base_addr
, &(pstatus
->data
.module_info
.base_address
), sizeof (base_addr
));
1681 dll_name_size
= pstatus
->data
.module_info
.module_name_size
;
1682 if (offsetof (struct win32_pstatus
, data
.module_info
.module_name
) + dll_name_size
> sect
->_raw_size
)
1685 dll_name
= (char *) xmalloc (dll_name_size
+ 1);
1688 printf_unfiltered ("memory allocation failed for %s\n", sect
->name
);
1691 strncpy (dll_name
, pstatus
->data
.module_info
.module_name
, dll_name_size
);
1693 while ((p
= strchr (dll_name
, '\\')))
1696 if (!core_dll_symbols_add (dll_name
, (DWORD
) base_addr
))
1697 printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name
);
1699 if (!dll_code_sections_add (dll_name
, (DWORD
) base_addr
+ 0x1000, target
))
1700 printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name
);
1711 child_solib_add (char *filename ATTRIBUTE_UNUSED
, int from_tty
, struct target_ops
*target
, int readsyms
)
1717 child_clear_solibs ();
1718 bfd_map_over_sections (core_bfd
, &core_section_load_dll_symbols
, target
);
1722 if (solib_end
&& solib_end
->name
)
1723 solib_symbols_add (solib_end
->name
, from_tty
, solib_end
->load_addr
);
1728 fetch_elf_core_registers (char *core_reg_sect
,
1729 unsigned core_reg_size
,
1734 if (core_reg_size
< sizeof (CONTEXT
))
1736 error ("Core file register section too small (%u bytes).", core_reg_size
);
1739 for (r
= 0; r
< NUM_REGS
; r
++)
1740 supply_register (r
, core_reg_sect
+ mappings
[r
]);
1743 static struct core_fns win32_elf_core_fns
=
1745 bfd_target_elf_flavour
,
1746 default_check_format
,
1747 default_core_sniffer
,
1748 fetch_elf_core_registers
,
1753 _initialize_core_win32 (void)
1755 add_core_fns (&win32_elf_core_fns
);
1759 _initialize_check_for_gdb_ini (void)
1762 if (inhibit_gdbinit
)
1765 homedir
= getenv ("HOME");
1769 char *oldini
= (char *) alloca (strlen (homedir
) +
1770 sizeof ("/gdb.ini"));
1771 strcpy (oldini
, homedir
);
1772 p
= strchr (oldini
, '\0');
1773 if (p
> oldini
&& p
[-1] != '/')
1775 strcpy (p
, "gdb.ini");
1776 if (access (oldini
, 0) == 0)
1778 int len
= strlen (oldini
);
1779 char *newini
= alloca (len
+ 1);
1780 sprintf (newini
, "%.*s.gdbinit", len
- (sizeof ("gdb.ini") - 1), oldini
);
1781 warning ("obsolete '%s' found. Rename to '%s'.", oldini
, newini
);