1 /* Target-vector operations for controlling win32 child processes, for GDB.
2 Copyright 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 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 */
35 #include <sys/types.h>
41 #else /* other WIN32 compiler */
49 #include "gdb_string.h"
50 #include "gdbthread.h"
52 #include <sys/param.h>
55 /* The ui's event loop. */
56 extern int (*ui_loop_hook
) PARAMS ((int signo
));
58 /* If we're not using the old Cygwin header file set, define the
59 following which never should have been in the generic Win32 API
60 headers in the first place since they were our own invention... */
61 #ifndef _GNU_H_WINDOWS_H
62 #define FLAG_TRACE_BIT 0x100
63 #define CONTEXT_DEBUGGER (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
66 /* The string sent by cygwin when it processes a signal.
67 FIXME: This should be in a cygwin include file. */
68 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
70 #define CHECK(x) check (x, __FILE__,__LINE__)
71 #define DEBUG_EXEC(x) if (debug_exec) printf x
72 #define DEBUG_EVENTS(x) if (debug_events) printf x
73 #define DEBUG_MEM(x) if (debug_memory) printf x
74 #define DEBUG_EXCEPT(x) if (debug_exceptions) printf x
76 /* Forward declaration */
77 extern struct target_ops child_ops
;
79 static void child_stop
PARAMS ((void));
80 static int win32_child_thread_alive
PARAMS ((int));
81 void child_kill_inferior
PARAMS ((void));
83 /* Thread information structure used to track information that is
84 not available in gdb's thread structure. */
85 typedef struct thread_info_struct
87 struct thread_info_struct
*next
;
96 static thread_info thread_head
= {NULL
};
98 /* The saved state for a continue after breaking back to gdb. */
99 static DWORD continue_status
;
101 /* The process and thread handles for the above context. */
103 static DEBUG_EVENT current_event
; /* The current debug event from
105 static HANDLE current_process_handle
; /* Currently executing process */
106 static thread_info
*current_thread
; /* Info on currently selected thread */
107 static DWORD main_thread_id
; /* Thread ID of the main thread */
109 /* Counts of things. */
110 static int exception_count
= 0;
111 static int event_count
= 0;
114 static int new_console
= 0;
115 static int new_group
= 1;
116 static int debug_exec
= 0; /* show execution */
117 static int debug_events
= 0; /* show events from kernel */
118 static int debug_memory
= 0; /* show target memory accesses */
119 static int debug_exceptions
= 0; /* show target exceptions */
121 /* This vector maps GDB's idea of a register's number into an address
122 in the win32 exception context vector.
124 It also contains the bit mask needed to load the register in question.
126 One day we could read a reg, we could inspect the context we
127 already have loaded, if it doesn't have the bit set that we need,
128 we read that set of registers in using GetThreadContext. If the
129 context already contains what we need, we just unpack it. Then to
130 write a register, first we have to ensure that the context contains
131 the other regs of the group, and then we copy the info in and set
134 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
135 static const int mappings
[] =
137 context_offset (Eax
),
138 context_offset (Ecx
),
139 context_offset (Edx
),
140 context_offset (Ebx
),
141 context_offset (Esp
),
142 context_offset (Ebp
),
143 context_offset (Esi
),
144 context_offset (Edi
),
145 context_offset (Eip
),
146 context_offset (EFlags
),
147 context_offset (SegCs
),
148 context_offset (SegSs
),
149 context_offset (SegDs
),
150 context_offset (SegEs
),
151 context_offset (SegFs
),
152 context_offset (SegGs
),
153 context_offset (FloatSave
.RegisterArea
[0 * 10]),
154 context_offset (FloatSave
.RegisterArea
[1 * 10]),
155 context_offset (FloatSave
.RegisterArea
[2 * 10]),
156 context_offset (FloatSave
.RegisterArea
[3 * 10]),
157 context_offset (FloatSave
.RegisterArea
[4 * 10]),
158 context_offset (FloatSave
.RegisterArea
[5 * 10]),
159 context_offset (FloatSave
.RegisterArea
[6 * 10]),
160 context_offset (FloatSave
.RegisterArea
[7 * 10]),
161 context_offset (FloatSave
.ControlWord
),
162 context_offset (FloatSave
.StatusWord
),
163 context_offset (FloatSave
.TagWord
),
164 context_offset (FloatSave
.ErrorSelector
),
165 context_offset (FloatSave
.ErrorOffset
),
166 context_offset (FloatSave
.DataSelector
),
167 context_offset (FloatSave
.DataOffset
),
168 context_offset (FloatSave
.ErrorSelector
)
171 #undef context_offset
173 /* This vector maps the target's idea of an exception (extracted
174 from the DEBUG_EVENT structure) to GDB's idea. */
176 struct xlate_exception
179 enum target_signal us
;
182 static const struct xlate_exception
185 {EXCEPTION_ACCESS_VIOLATION
, TARGET_SIGNAL_SEGV
},
186 {STATUS_STACK_OVERFLOW
, TARGET_SIGNAL_SEGV
},
187 {EXCEPTION_BREAKPOINT
, TARGET_SIGNAL_TRAP
},
188 {DBG_CONTROL_C
, TARGET_SIGNAL_INT
},
189 {EXCEPTION_SINGLE_STEP
, TARGET_SIGNAL_TRAP
},
192 /* Find a thread record given a thread id.
193 If get_context then also retrieve the context for this
196 thread_rec (DWORD id
, int get_context
)
200 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
203 if (!th
->suspend_count
&& get_context
)
206 th
->suspend_count
= SuspendThread (th
->h
) + 1;
207 else if (get_context
< 0)
208 th
->suspend_count
= -1;
210 th
->context
.ContextFlags
= CONTEXT_DEBUGGER
;
211 GetThreadContext (th
->h
, &th
->context
);
219 /* Add a thread to the thread list */
221 child_add_thread (DWORD id
, HANDLE h
)
225 if ((th
= thread_rec (id
, FALSE
)))
228 th
= (thread_info
*) xmalloc (sizeof (*th
));
229 memset (th
, 0, sizeof (*th
));
232 th
->next
= thread_head
.next
;
233 thread_head
.next
= th
;
238 /* Clear out any old thread list and reintialize it to a
241 child_init_thread_list ()
243 thread_info
*th
= &thread_head
;
245 DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
247 while (th
->next
!= NULL
)
249 thread_info
*here
= th
->next
;
250 th
->next
= here
->next
;
251 (void) CloseHandle (here
->h
);
256 /* Delete a thread from the list of threads */
258 child_delete_thread (DWORD id
)
263 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (id
));
266 for (th
= &thread_head
;
267 th
->next
!= NULL
&& th
->next
->id
!= id
;
271 if (th
->next
!= NULL
)
273 thread_info
*here
= th
->next
;
274 th
->next
= here
->next
;
275 CloseHandle (here
->h
);
281 check (BOOL ok
, const char *file
, int line
)
284 printf_filtered ("error return %s:%d was %d\n", file
, line
, GetLastError ());
288 do_child_fetch_inferior_registers (int r
)
290 char *context_offset
= ((char *) ¤t_thread
->context
) + mappings
[r
];
294 l
= *((long *)context_offset
) & 0xffff;
295 supply_register (r
, (char *) &l
);
297 else if (r
== FOP_REGNUM
)
299 l
= (*((long *)context_offset
) >> 16) & ((1 << 11) - 1);
300 supply_register (r
, (char *) &l
);
303 supply_register (r
, context_offset
);
306 for (r
= 0; r
< NUM_REGS
; r
++)
307 do_child_fetch_inferior_registers (r
);
312 child_fetch_inferior_registers (int r
)
314 current_thread
= thread_rec (inferior_pid
, TRUE
);
315 do_child_fetch_inferior_registers (r
);
319 do_child_store_inferior_registers (int r
)
322 read_register_gen (r
, ((char *) ¤t_thread
->context
) + mappings
[r
]);
325 for (r
= 0; r
< NUM_REGS
; r
++)
326 do_child_store_inferior_registers (r
);
330 /* Store a new register value into the current thread context */
332 child_store_inferior_registers (int r
)
334 current_thread
= thread_rec (inferior_pid
, TRUE
);
335 do_child_store_inferior_registers (r
);
339 static int psapi_loaded
= 0;
340 static HMODULE psapi_module_handle
= NULL
;
341 static BOOL
WINAPI (*psapi_EnumProcessModules
)(HANDLE
, HMODULE
*, DWORD
, LPDWORD
)= NULL
;
342 static BOOL
WINAPI (*psapi_GetModuleInformation
) (HANDLE
, HMODULE
, LPMODULEINFO
, DWORD
)= NULL
;
343 static DWORD
WINAPI (*psapi_GetModuleFileNameExA
) (HANDLE
, HMODULE
, LPSTR
, DWORD
)= NULL
;
345 int psapi_get_dll_name (DWORD BaseAddress
, char *dll_name_ret
)
350 HMODULE dh_buf
[ 1 ];
351 HMODULE
* DllHandle
= dh_buf
;
356 psapi_EnumProcessModules
== NULL
||
357 psapi_GetModuleInformation
== NULL
||
358 psapi_GetModuleFileNameExA
== NULL
)
360 if (psapi_loaded
)goto failed
;
362 psapi_module_handle
= LoadLibrary ("psapi.dll");
363 if (!psapi_module_handle
)
365 /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ());*/
368 psapi_EnumProcessModules
= GetProcAddress (psapi_module_handle
, "EnumProcessModules" );
369 psapi_GetModuleInformation
= GetProcAddress (psapi_module_handle
, "GetModuleInformation");
370 psapi_GetModuleFileNameExA
= (void *) GetProcAddress (psapi_module_handle
,
371 "GetModuleFileNameExA");
372 if (psapi_EnumProcessModules
== NULL
||
373 psapi_GetModuleInformation
== NULL
||
374 psapi_GetModuleFileNameExA
== NULL
)
379 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
384 if (!ok
|| !cbNeeded
)
387 DllHandle
= (HMODULE
*) alloca (cbNeeded
);
391 ok
= (*psapi_EnumProcessModules
) (current_process_handle
,
398 for (i
= 0; i
< cbNeeded
/ sizeof (HMODULE
); i
++)
400 if (!(*psapi_GetModuleInformation
) (current_process_handle
,
404 error ("Can't get module info");
406 len
= (*psapi_GetModuleFileNameExA
) (current_process_handle
,
411 error ("Error getting dll name: %u\n", GetLastError ());
413 if ((DWORD
) (mi
.lpBaseOfDll
) == BaseAddress
)
418 dll_name_ret
[0] = '\0';
422 /* Wait for child to do something. Return pid of child, or -1 in case
423 of error; store status through argument pointer OURSTATUS. */
426 handle_load_dll (PTR dummy
)
428 LOAD_DLL_DEBUG_INFO
*event
= ¤t_event
.u
.LoadDll
;
431 char dll_buf
[MAX_PATH
+ 1];
432 char *p
, *dll_name
= NULL
;
433 struct objfile
*objfile
;
434 MEMORY_BASIC_INFORMATION minfo
;
435 struct section_addr_info section_addrs
;
437 memset (§ion_addrs
, 0, sizeof (section_addrs
));
438 dll_buf
[0] = dll_buf
[sizeof (dll_buf
) - 1] = '\0';
440 if (!psapi_get_dll_name ((DWORD
) (event
->lpBaseOfDll
), dll_buf
))
441 dll_buf
[0] = dll_buf
[sizeof(dll_buf
) - 1] = '\0';
445 /* Attempt to read the name of the dll that was detected.
446 This is documented to work only when actively debugging
447 a program. It will not work for attached processes. */
448 if (dll_name
== NULL
|| *dll_name
== '\0')
450 int size
= event
->fUnicode
? sizeof (WCHAR
) : sizeof (char);
454 ReadProcessMemory (current_process_handle
,
455 (LPCVOID
) event
->lpImageName
,
456 (char *) &dll_name_ptr
,
457 sizeof (dll_name_ptr
), &done
);
459 /* See if we could read the address of a string, and that the
460 address isn't null. */
462 if (done
!= sizeof (dll_name_ptr
) || !dll_name_ptr
)
467 ReadProcessMemory (current_process_handle
,
468 (LPCVOID
) (dll_name_ptr
+ len
* size
),
474 while ((b
[0] != 0 || b
[size
- 1] != 0) && done
== size
);
476 dll_name
= alloca (len
);
480 WCHAR
*unicode_dll_name
= (WCHAR
*) alloca (len
* sizeof (WCHAR
));
481 ReadProcessMemory (current_process_handle
,
482 (LPCVOID
) dll_name_ptr
,
484 len
* sizeof (WCHAR
),
487 WideCharToMultiByte (CP_ACP
, 0,
488 unicode_dll_name
, len
,
489 dll_name
, len
, 0, 0);
493 ReadProcessMemory (current_process_handle
,
494 (LPCVOID
) dll_name_ptr
,
504 while ((p
= strchr (dll_name
, '\\')))
507 /* The symbols in a dll are offset by 0x1000, which is the
508 the offset from 0 of the first byte in an image - because
509 of the file header and the section alignment.
511 FIXME: Is this the real reason that we need the 0x1000 ? */
513 printf_unfiltered ("%x:%s", event
->lpBaseOfDll
, dll_name
);
514 section_addrs
.text_addr
= (int) event
->lpBaseOfDll
+ 0x1000;
515 symbol_file_add (dll_name
, 0, §ion_addrs
, 0, OBJF_SHARED
);
516 printf_unfiltered ("\n");
521 /* Handle DEBUG_STRING output from child process.
522 Cygwin prepends its messages with a "cygwin:". Interpret this as
523 a Cygwin signal. Otherwise just print the string as a warning. */
525 handle_output_debug_string (struct target_waitstatus
*ourstatus
)
530 if (!target_read_string
531 ((CORE_ADDR
) current_event
.u
.DebugString
.lpDebugStringData
, &s
, 1024, 0)
535 if (strncmp (s
, CYGWIN_SIGNAL_STRING
, sizeof (CYGWIN_SIGNAL_STRING
) - 1) != 0)
537 if (strncmp (s
, "cYg", 3) != 0)
543 int sig
= strtol (s
+ sizeof (CYGWIN_SIGNAL_STRING
) - 1, &p
, 0);
544 gotasig
= target_signal_from_host (sig
);
545 ourstatus
->value
.sig
= gotasig
;
547 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
555 handle_exception (struct target_waitstatus
*ourstatus
)
561 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
563 /* Record the context of the current thread */
564 th
= thread_rec (current_event
.dwThreadId
, -1);
566 switch (current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
)
568 case EXCEPTION_ACCESS_VIOLATION
:
569 DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
570 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
571 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
572 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
574 case STATUS_STACK_OVERFLOW
:
575 DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
576 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
577 ourstatus
->value
.sig
= TARGET_SIGNAL_SEGV
;
578 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
580 case EXCEPTION_BREAKPOINT
:
581 DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
582 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
583 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
586 DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
587 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
588 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
589 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
591 case EXCEPTION_SINGLE_STEP
:
592 DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
593 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
));
594 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
597 /* This may be a structured exception handling exception. In
598 that case, we want to let the program try to handle it, and
599 only break if we see the exception a second time.
600 if (current_event.u.Exception.dwFirstChance)
605 printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
606 current_event
.u
.Exception
.ExceptionRecord
.ExceptionCode
,
607 current_event
.u
.Exception
.ExceptionRecord
.ExceptionAddress
);
608 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
609 continue_status
= DBG_EXCEPTION_NOT_HANDLED
;
616 /* Resume all artificially suspended threads if we are continuing
619 child_continue (int id
)
625 DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
626 current_event
.dwProcessId
, current_event
.dwThreadId
));
627 res
= ContinueDebugEvent (current_event
.dwProcessId
,
628 current_event
.dwThreadId
,
632 for (th
= &thread_head
; (th
= th
->next
) != NULL
;)
633 if (((id
== -1) || (id
== th
->id
)) && th
->suspend_count
)
635 for (i
= 0; i
< th
->suspend_count
; i
++)
636 (void) ResumeThread (th
->h
);
637 th
->suspend_count
= 0;
644 get_child_debug_event (int pid
, struct target_waitstatus
*ourstatus
,
645 DWORD
*event_code
, int *retval
)
650 if (!(debug_event
= WaitForDebugEvent (¤t_event
, 20)))
652 breakout
= *retval
= *event_code
= 0;
657 continue_status
= DBG_CONTINUE
;
660 switch (*event_code
= current_event
.dwDebugEventCode
)
662 case CREATE_THREAD_DEBUG_EVENT
:
663 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
664 (unsigned) current_event
.dwProcessId
,
665 (unsigned) current_event
.dwThreadId
,
666 "CREATE_THREAD_DEBUG_EVENT"));
667 /* Record the existence of this thread */
668 child_add_thread (current_event
.dwThreadId
,
669 current_event
.u
.CreateThread
.hThread
);
671 printf_unfiltered ("[New %s]\n",
672 target_pid_to_str (current_event
.dwThreadId
));
675 case EXIT_THREAD_DEBUG_EVENT
:
676 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
677 (unsigned) current_event
.dwProcessId
,
678 (unsigned) current_event
.dwThreadId
,
679 "EXIT_THREAD_DEBUG_EVENT"));
680 child_delete_thread (current_event
.dwThreadId
);
683 case CREATE_PROCESS_DEBUG_EVENT
:
684 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
685 (unsigned) current_event
.dwProcessId
,
686 (unsigned) current_event
.dwThreadId
,
687 "CREATE_PROCESS_DEBUG_EVENT"));
688 current_process_handle
= current_event
.u
.CreateProcessInfo
.hProcess
;
690 main_thread_id
= inferior_pid
= current_event
.dwThreadId
;
691 /* Add the main thread */
692 current_thread
= child_add_thread (inferior_pid
,
693 current_event
.u
.CreateProcessInfo
.hThread
);
696 case EXIT_PROCESS_DEBUG_EVENT
:
697 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
698 (unsigned) current_event
.dwProcessId
,
699 (unsigned) current_event
.dwThreadId
,
700 "EXIT_PROCESS_DEBUG_EVENT"));
701 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
702 ourstatus
->value
.integer
= current_event
.u
.ExitProcess
.dwExitCode
;
703 CloseHandle (current_process_handle
);
704 *retval
= current_event
.dwProcessId
;
707 case LOAD_DLL_DEBUG_EVENT
:
708 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
709 (unsigned) current_event
.dwProcessId
,
710 (unsigned) current_event
.dwThreadId
,
711 "LOAD_DLL_DEBUG_EVENT"));
712 catch_errors (handle_load_dll
, NULL
, "", RETURN_MASK_ALL
);
713 registers_changed (); /* mark all regs invalid */
716 case UNLOAD_DLL_DEBUG_EVENT
:
717 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
718 (unsigned) current_event
.dwProcessId
,
719 (unsigned) current_event
.dwThreadId
,
720 "UNLOAD_DLL_DEBUG_EVENT"));
721 break; /* FIXME: don't know what to do here */
723 case EXCEPTION_DEBUG_EVENT
:
724 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
725 (unsigned) current_event
.dwProcessId
,
726 (unsigned) current_event
.dwThreadId
,
727 "EXCEPTION_DEBUG_EVENT"));
728 if (handle_exception (ourstatus
)) /* sets continue_status */
730 *retval
= current_event
.dwThreadId
;
735 case OUTPUT_DEBUG_STRING_EVENT
:
736 DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
737 (unsigned) current_event
.dwProcessId
,
738 (unsigned) current_event
.dwThreadId
,
739 "OUTPUT_DEBUG_STRING_EVENT"));
740 if (handle_output_debug_string (ourstatus
))
742 *retval
= main_thread_id
;
747 printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
748 current_event
.dwProcessId
,
749 current_event
.dwThreadId
);
750 printf_unfiltered (" unknown event code %d\n",
751 current_event
.dwDebugEventCode
);
756 CHECK (child_continue (-1));
764 /* Wait for interesting events to occur in the target process. */
766 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
771 /* We loop when we get a non-standard exception rather than return
772 with a SPURIOUS because resume can try and step or modify things,
773 which needs a current_thread->h. But some of these exceptions mark
774 the birth or death of threads, which mean that the current thread
775 isn't necessarily what you think it is. */
779 if (continue_status
!= 0)
780 CHECK (child_continue (-1));
781 if (get_child_debug_event (pid
, ourstatus
, &event_code
, &retval
))
787 if (ui_loop_hook
!= NULL
)
788 detach
= ui_loop_hook (0);
791 child_kill_inferior ();
796 /* Attach to process PID, then initialize for debugging it. */
799 child_attach (args
, from_tty
)
806 error_no_arg ("process-id to attach");
808 current_event
.dwProcessId
= strtoul (args
, 0, 0);
810 ok
= DebugActiveProcess (current_event
.dwProcessId
);
813 error ("Can't attach to process.");
820 char *exec_file
= (char *) get_exec_file (0);
823 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
824 target_pid_to_str (current_event
.dwProcessId
));
826 printf_unfiltered ("Attaching to %s\n",
827 target_pid_to_str (current_event
.dwProcessId
));
829 gdb_flush (gdb_stdout
);
832 push_target (&child_ops
);
836 child_detach (args
, from_tty
)
842 char *exec_file
= get_exec_file (0);
845 printf_unfiltered ("Detaching from program: %s %s\n", exec_file
,
846 target_pid_to_str (inferior_pid
));
847 gdb_flush (gdb_stdout
);
850 unpush_target (&child_ops
);
853 /* Print status information about what we're accessing. */
856 child_files_info (ignore
)
857 struct target_ops
*ignore
;
859 printf_unfiltered ("\tUsing the running image of %s %s.\n",
860 attach_flag
? "attached" : "child", target_pid_to_str (inferior_pid
));
865 child_open (arg
, from_tty
)
869 error ("Use the \"run\" command to start a Unix child process.");
872 /* Start an inferior win32 child process and sets inferior_pid to its pid.
873 EXEC_FILE is the file to run.
874 ALLARGS is a string containing the arguments to the program.
875 ENV is the environment vector to pass. Errors reported with error(). */
878 child_create_inferior (exec_file
, allargs
, env
)
883 char real_path
[MAXPATHLEN
];
889 PROCESS_INFORMATION pi
;
890 struct target_waitstatus dummy
;
898 error ("No executable specified, use `target exec'.\n");
901 memset (&si
, 0, sizeof (si
));
904 cygwin32_conv_to_win32_path (exec_file
, real_path
);
906 flags
= DEBUG_ONLY_THIS_PROCESS
;
909 flags
|= CREATE_NEW_PROCESS_GROUP
;
912 flags
|= CREATE_NEW_CONSOLE
;
914 args
= alloca (strlen (real_path
) + strlen (allargs
) + 2);
916 strcpy (args
, real_path
);
919 strcat (args
, allargs
);
921 /* Prepare the environment vars for CreateProcess. */
923 /* This code use to assume all env vars were file names and would
924 translate them all to win32 style. That obviously doesn't work in the
925 general case. The current rule is that we only translate PATH.
926 We need to handle PATH because we're about to call CreateProcess and
927 it uses PATH to find DLL's. Fortunately PATH has a well-defined value
928 in both posix and win32 environments. cygwin.dll will change it back
929 to posix style if necessary. */
931 static const char *conv_path_names
[] =
937 /* CreateProcess takes the environment list as a null terminated set of
938 strings (i.e. two nulls terminate the list). */
940 /* Get total size for env strings. */
941 for (envlen
= 0, i
= 0; env
[i
] && *env
[i
]; i
++)
945 for (j
= 0; conv_path_names
[j
]; j
++)
947 len
= strlen (conv_path_names
[j
]);
948 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
950 if (cygwin32_posix_path_list_p (env
[i
] + len
))
952 + cygwin32_posix_to_win32_path_list_buf_size (env
[i
] + len
);
954 envlen
+= strlen (env
[i
]) + 1;
958 if (conv_path_names
[j
] == NULL
)
959 envlen
+= strlen (env
[i
]) + 1;
962 winenv
= alloca (envlen
+ 1);
964 /* Copy env strings into new buffer. */
965 for (temp
= winenv
, i
= 0; env
[i
] && *env
[i
]; i
++)
969 for (j
= 0; conv_path_names
[j
]; j
++)
971 len
= strlen (conv_path_names
[j
]);
972 if (strncmp (conv_path_names
[j
], env
[i
], len
) == 0)
974 if (cygwin32_posix_path_list_p (env
[i
] + len
))
976 memcpy (temp
, env
[i
], len
);
977 cygwin32_posix_to_win32_path_list (env
[i
] + len
, temp
+ len
);
980 strcpy (temp
, env
[i
]);
984 if (conv_path_names
[j
] == NULL
)
985 strcpy (temp
, env
[i
]);
987 temp
+= strlen (temp
) + 1;
990 /* Final nil string to terminate new env. */
994 ret
= CreateProcess (0,
995 args
, /* command line */
998 TRUE
, /* inherit handles */
999 flags
, /* start flags */
1001 NULL
, /* current directory */
1005 error ("Error creating process %s, (error %d)\n", exec_file
, GetLastError ());
1007 exception_count
= 0;
1010 current_process_handle
= pi
.hProcess
;
1011 current_event
.dwProcessId
= pi
.dwProcessId
;
1012 memset (¤t_event
, 0, sizeof (current_event
));
1013 inferior_pid
= current_event
.dwThreadId
= pi
.dwThreadId
;
1014 push_target (&child_ops
);
1015 child_init_thread_list ();
1016 init_wait_for_inferior ();
1017 clear_proceed_status ();
1018 target_terminal_init ();
1019 target_terminal_inferior ();
1021 /* Run until process and threads are loaded */
1023 get_child_debug_event (inferior_pid
, &dummy
, &event_code
, &ret
);
1024 while (event_code
!= EXCEPTION_DEBUG_EVENT
);
1026 SymSetOptions (SYMOPT_DEFERRED_LOADS
);
1027 SymInitialize (current_process_handle
, NULL
, TRUE
);
1029 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
1033 child_mourn_inferior ()
1035 continue_status
= DBG_CONTINUE
;
1036 (void) child_continue (-1);
1037 unpush_target (&child_ops
);
1038 generic_mourn_inferior ();
1041 /* Send a SIGINT to the process group. This acts just like the user typed a
1042 ^C on the controlling terminal. */
1047 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1048 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT
, current_event
.dwProcessId
));
1049 registers_changed (); /* refresh register state */
1053 child_xfer_memory (CORE_ADDR memaddr
, char *our
, int len
,
1054 int write
, struct target_ops
*target
)
1059 DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08x\n",
1061 WriteProcessMemory (current_process_handle
, (LPVOID
) memaddr
, our
,
1063 FlushInstructionCache (current_process_handle
, (LPCVOID
) memaddr
, len
);
1067 DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08x\n",
1069 ReadProcessMemory (current_process_handle
, (LPCVOID
) memaddr
, our
, len
,
1076 child_kill_inferior (void)
1078 CHECK (TerminateProcess (current_process_handle
, 0));
1082 continue_status
= DBG_CONTINUE
;
1083 if (!child_continue (-1))
1085 if (!WaitForDebugEvent (¤t_event
, INFINITE
))
1087 if (current_event
.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT
)
1091 CHECK (CloseHandle (current_process_handle
));
1093 /* this may fail in an attached process so don't check. */
1094 (void) CloseHandle (current_thread
->h
);
1095 target_mourn_inferior (); /* or just child_mourn_inferior? */
1099 child_resume (int pid
, int step
, enum target_signal sig
)
1104 DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1107 /* Get context for currently selected thread */
1108 th
= thread_rec (current_event
.dwThreadId
, FALSE
);
1112 /* Single step by setting t bit */
1113 child_fetch_inferior_registers (PS_REGNUM
);
1114 th
->context
.EFlags
|= FLAG_TRACE_BIT
;
1118 if (th
->context
.ContextFlags
)
1120 CHECK (SetThreadContext (th
->h
, &th
->context
));
1121 th
->context
.ContextFlags
= 0;
1124 /* Allow continuing with the same signal that interrupted us.
1125 Otherwise complain. */
1127 child_continue (pid
);
1131 child_prepare_to_store ()
1133 /* Do nothing, since we can store individual regs */
1145 DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid
));
1148 struct target_ops child_ops
;
1151 init_child_ops (void)
1153 child_ops
.to_shortname
= "child";
1154 child_ops
.to_longname
= "Win32 child process";
1155 child_ops
.to_doc
= "Win32 child process (started by the \"run\" command).";
1156 child_ops
.to_open
= child_open
;
1157 child_ops
.to_close
= child_close
;
1158 child_ops
.to_attach
= child_attach
;
1159 child_ops
.to_detach
= child_detach
;
1160 child_ops
.to_resume
= child_resume
;
1161 child_ops
.to_wait
= child_wait
;
1162 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
1163 child_ops
.to_store_registers
= child_store_inferior_registers
;
1164 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
1165 child_ops
.to_xfer_memory
= child_xfer_memory
;
1166 child_ops
.to_files_info
= child_files_info
;
1167 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1168 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1169 child_ops
.to_terminal_init
= terminal_init_inferior
;
1170 child_ops
.to_terminal_inferior
= terminal_inferior
;
1171 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1172 child_ops
.to_terminal_ours
= terminal_ours
;
1173 child_ops
.to_terminal_info
= child_terminal_info
;
1174 child_ops
.to_kill
= child_kill_inferior
;
1175 child_ops
.to_load
= 0;
1176 child_ops
.to_lookup_symbol
= 0;
1177 child_ops
.to_create_inferior
= child_create_inferior
;
1178 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
1179 child_ops
.to_can_run
= child_can_run
;
1180 child_ops
.to_notice_signals
= 0;
1181 child_ops
.to_thread_alive
= win32_child_thread_alive
;
1182 child_ops
.to_pid_to_str
= cygwin_pid_to_str
;
1183 child_ops
.to_stop
= child_stop
;
1184 child_ops
.to_stratum
= process_stratum
;
1185 child_ops
.DONT_USE
= 0;
1186 child_ops
.to_has_all_memory
= 1;
1187 child_ops
.to_has_memory
= 1;
1188 child_ops
.to_has_stack
= 1;
1189 child_ops
.to_has_registers
= 1;
1190 child_ops
.to_has_execution
= 1;
1191 child_ops
.to_sections
= 0;
1192 child_ops
.to_sections_end
= 0;
1193 child_ops
.to_magic
= OPS_MAGIC
;
1197 _initialize_inftarg ()
1199 struct cmd_list_element
*c
;
1203 (add_set_cmd ("new-console", class_support
, var_boolean
,
1204 (char *) &new_console
,
1205 "Set creation of new console when creating child process.",
1210 (add_set_cmd ("new-group", class_support
, var_boolean
,
1211 (char *) &new_group
,
1212 "Set creation of new group when creating child process.",
1217 (add_set_cmd ("debugexec", class_support
, var_boolean
,
1218 (char *) &debug_exec
,
1219 "Set whether to display execution in child process.",
1224 (add_set_cmd ("debugevents", class_support
, var_boolean
,
1225 (char *) &debug_events
,
1226 "Set whether to display kernel events in child process.",
1231 (add_set_cmd ("debugmemory", class_support
, var_boolean
,
1232 (char *) &debug_memory
,
1233 "Set whether to display memory accesses in child process.",
1238 (add_set_cmd ("debugexceptions", class_support
, var_boolean
,
1239 (char *) &debug_exceptions
,
1240 "Set whether to display kernel exceptions in child process.",
1244 add_target (&child_ops
);
1247 /* Determine if the thread referenced by "pid" is alive
1248 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
1249 it means that the pid has died. Otherwise it is assumed to be alive. */
1251 win32_child_thread_alive (int pid
)
1253 return WaitForSingleObject (thread_rec (pid
, FALSE
)->h
, 0) == WAIT_OBJECT_0
?
1257 /* Convert pid to printable format. */
1259 cygwin_pid_to_str (int pid
)
1261 static char buf
[80];
1262 if (pid
== current_event
.dwProcessId
)
1263 sprintf (buf
, "process %d", pid
);
1265 sprintf (buf
, "thread %d.0x%x", current_event
.dwProcessId
, pid
);
1269 static LPVOID __stdcall
1270 sfta(HANDLE h
, DWORD d
)
1275 static DWORD __stdcall
1276 sgmb(HANDLE h
, DWORD d
)
1281 return SymGetModuleBase (h
, d
) ?: 4;
1286 child_frame_chain(struct frame_info
*f
)
1288 STACKFRAME
*sf
= (STACKFRAME
*) f
->extra_info
;
1289 if (!StackWalk (IMAGE_FILE_MACHINE_I386
, current_process_handle
,
1290 current_thread
->h
, sf
, NULL
, NULL
, SymFunctionTableAccess
, sgmb
, NULL
) ||
1291 !sf
->AddrReturn
.Offset
)
1293 return sf
->AddrFrame
.Offset
;
1297 child_frame_saved_pc(struct frame_info
*f
)
1299 STACKFRAME
*sf
= (STACKFRAME
*) f
->extra_info
;
1300 return sf
->AddrReturn
.Offset
;
1304 child_init_frame(int leaf
, struct frame_info
*f
)
1308 if (f
->next
&& f
->next
->extra_info
)
1309 f
->extra_info
= f
->next
->extra_info
;
1310 else if (f
->prev
&& f
->prev
->extra_info
)
1311 f
->extra_info
= f
->prev
->extra_info
;
1314 sf
= (STACKFRAME
*) frame_obstack_alloc (sizeof (*sf
));
1315 f
->extra_info
= (struct frame_extra_info
*) sf
;
1316 memset (sf
, 0, sizeof(*sf
));
1317 sf
->AddrPC
.Offset
= f
->pc
;
1318 sf
->AddrPC
.Mode
= AddrModeFlat
;
1319 sf
->AddrStack
.Offset
= current_thread
->context
.Esp
;
1320 sf
->AddrStack
.Mode
= AddrModeFlat
;
1321 sf
->AddrFrame
.Offset
= f
->frame
;
1322 sf
->AddrFrame
.Mode
= AddrModeFlat
;