You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-*/
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+ */
/* by Steve Chamberlain, sac@cygnus.com */
#include "gdbthread.h"
#include "gdbcmd.h"
#include <sys/param.h>
-#include <unistd.h>
+
+/* The ui's event loop. */
+extern int (*ui_loop_hook) PARAMS ((int signo));
+
+/* If we're not using the old Cygwin header file set, define the
+ following which never should have been in the generic Win32 API
+ headers in the first place since they were our own invention... */
+#ifndef _GNU_H_WINDOWS_H
+#define FLAG_TRACE_BIT 0x100
+#define CONTEXT_DEBUGGER (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
+#endif
/* The string sent by cygwin when it processes a signal.
FIXME: This should be in a cygwin include file. */
extern struct target_ops child_ops;
static void child_stop PARAMS ((void));
-static int child_thread_alive PARAMS ((int));
+static int win32_child_thread_alive PARAMS ((int));
+void child_kill_inferior PARAMS ((void));
static int last_sig = 0; /* Set if a signal was received from the
debugged process */
/* Thread information structure used to track information that is
not available in gdb's thread structure. */
typedef struct thread_info_struct
-{
- struct thread_info_struct *next;
- DWORD id;
- HANDLE h;
- char *name;
- int suspend_count;
- CONTEXT context;
-} thread_info;
+ {
+ struct thread_info_struct *next;
+ DWORD id;
+ HANDLE h;
+ char *name;
+ int suspend_count;
+ CONTEXT context;
+ }
+thread_info;
-static thread_info thread_head = {NULL};
+static thread_info thread_head =
+{NULL};
/* The process and thread handles for the above context. */
WaitForDebugEvent */
static HANDLE current_process_handle; /* Currently executing process */
static thread_info *current_thread; /* Info on currently selected thread */
-static DWORD main_thread_id; /* Thread ID of the main thread */
+static DWORD main_thread_id; /* Thread ID of the main thread */
/* Counts of things. */
static int exception_count = 0;
/* User options. */
static int new_console = 0;
static int new_group = 0;
-static int debug_exec = 0; /* show execution */
-static int debug_events = 0; /* show events from kernel */
-static int debug_memory = 0; /* show target memory accesses */
+static int debug_exec = 0; /* show execution */
+static int debug_events = 0; /* show events from kernel */
+static int debug_memory = 0; /* show target memory accesses */
static int debug_exceptions = 0; /* show target exceptions */
/* This vector maps GDB's idea of a register's number into an address
#define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
static const int mappings[] =
{
- context_offset(Eax),
- context_offset(Ecx),
- context_offset(Edx),
- context_offset(Ebx),
- context_offset(Esp),
- context_offset(Ebp),
- context_offset(Esi),
- context_offset(Edi),
- context_offset(Eip),
- context_offset(EFlags),
- context_offset(SegCs),
- context_offset(SegSs),
- context_offset(SegDs),
- context_offset(SegEs),
- context_offset(SegFs),
- context_offset(SegGs),
- context_offset(FloatSave.RegisterArea[0 * 10]),
- context_offset(FloatSave.RegisterArea[1 * 10]),
- context_offset(FloatSave.RegisterArea[2 * 10]),
- context_offset(FloatSave.RegisterArea[3 * 10]),
- context_offset(FloatSave.RegisterArea[4 * 10]),
- context_offset(FloatSave.RegisterArea[5 * 10]),
- context_offset(FloatSave.RegisterArea[6 * 10]),
- context_offset(FloatSave.RegisterArea[7 * 10]),
+ context_offset (Eax),
+ context_offset (Ecx),
+ context_offset (Edx),
+ context_offset (Ebx),
+ context_offset (Esp),
+ context_offset (Ebp),
+ context_offset (Esi),
+ context_offset (Edi),
+ context_offset (Eip),
+ context_offset (EFlags),
+ context_offset (SegCs),
+ context_offset (SegSs),
+ context_offset (SegDs),
+ context_offset (SegEs),
+ context_offset (SegFs),
+ context_offset (SegGs),
+ context_offset (FloatSave.RegisterArea[0 * 10]),
+ context_offset (FloatSave.RegisterArea[1 * 10]),
+ context_offset (FloatSave.RegisterArea[2 * 10]),
+ context_offset (FloatSave.RegisterArea[3 * 10]),
+ context_offset (FloatSave.RegisterArea[4 * 10]),
+ context_offset (FloatSave.RegisterArea[5 * 10]),
+ context_offset (FloatSave.RegisterArea[6 * 10]),
+ context_offset (FloatSave.RegisterArea[7 * 10]),
};
/* This vector maps the target's idea of an exception (extracted
{
thread_info *th;
- for (th = &thread_head; (th = th->next) != NULL; )
+ for (th = &thread_head; (th = th->next) != NULL;)
if (th->id == id)
{
if (!th->suspend_count && get_context)
/* Add a thread to the thread list */
static thread_info *
-child_add_thread(DWORD id, HANDLE h)
+child_add_thread (DWORD id, HANDLE h)
{
thread_info *th;
return th;
th = (thread_info *) xmalloc (sizeof (*th));
- memset(th, 0, sizeof (*th));
+ memset (th, 0, sizeof (*th));
th->id = id;
th->h = h;
th->next = thread_head.next;
of error; store status through argument pointer OURSTATUS. */
static int
-handle_load_dll (char *dummy)
+handle_load_dll (PTR dummy)
{
- LOAD_DLL_DEBUG_INFO * event = ¤t_event.u.LoadDll;
+ LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
DWORD dll_name_ptr;
DWORD done;
char dll_buf[MAX_PATH + 1];
- char *p, *dll_name = NULL, *dll_basename;
+ char *p, *dll_name = NULL;
struct objfile *objfile;
MEMORY_BASIC_INFORMATION minfo;
+ struct section_addr_info section_addrs;
- dll_buf[0] = dll_buf[sizeof(dll_buf) - 1] = '\0';
+ memset (§ion_addrs, 0, sizeof (section_addrs));
+ dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
/* The following code attempts to find the name of the dll by reading the
name from the processes memory. Unfortunately it doesn't work right.
#ifdef DOESNT_WORK
memset (&minfo, 0, sizeof minfo);
if (VirtualQueryEx (current_process_handle, (LPCVOID) event->lpBaseOfDll,
- &minfo, sizeof(minfo)) && minfo.BaseAddress) {
+ &minfo, sizeof (minfo)) && minfo.BaseAddress)
+ {
DWORD len;
IMAGE_DOS_HEADER *hmm0 = (IMAGE_DOS_HEADER *) minfo.BaseAddress;
HMODULE hmm = (HMODULE) (((DWORD) hmm0) + hmm0->e_lfanew);
dll_name = dll_buf;
dll_name[len] = '\0';
}
- }
+ }
#endif
/* Attempt to read the name of the dll that was detected.
sizeof (dll_name_ptr), &done);
/* See if we could read the address of a string, and that the
- address isn't null. */
+ address isn't null. */
if (done != sizeof (dll_name_ptr) || !dll_name_ptr)
return 1;
while ((p = strchr (dll_name, '\\')))
*p = '/';
- /* FIXME!! It would be nice to define one symbol which pointed to the
- front of the dll if we can't find any symbols. */
-
- if (!(dll_basename = strrchr(dll_name, '/')))
- dll_basename = dll_name;
- else
- dll_basename++;
-
- ALL_OBJFILES(objfile)
- {
- char *objfile_basename;
- objfile_basename = strrchr(objfile->name, '/');
-
- if (objfile_basename &&
- strcmp(dll_basename, objfile_basename + 1) == 0)
- {
- printf_unfiltered ("%x:%s (symbols previously loaded)\n",
- event->lpBaseOfDll, dll_name);
- goto out;
- }
- }
-
/* The symbols in a dll are offset by 0x1000, which is the
the offset from 0 of the first byte in an image - because
of the file header and the section alignment.
FIXME: Is this the real reason that we need the 0x1000 ? */
printf_unfiltered ("%x:%s", event->lpBaseOfDll, dll_name);
- symbol_file_add (dll_name, 0, (int) event->lpBaseOfDll + 0x1000, 0, 0, 0);
+ section_addrs.text_addr = (int) event->lpBaseOfDll + 0x1000;
+ symbol_file_add (dll_name, 0, §ion_addrs, 0, OBJF_SHARED);
printf_unfiltered ("\n");
-out:
return 1;
}
int gotasig = FALSE;
if (!target_read_string
- ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
+ ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
|| !s || !*s)
return gotasig;
- if (strncmp(s, CYGWIN_SIGNAL_STRING, sizeof(CYGWIN_SIGNAL_STRING) - 1))
+ if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1))
{
warning (s);
}
else
{
char *p;
- /*last_sig = */strtol(s + sizeof(CYGWIN_SIGNAL_STRING) - 1, &p, 0);
- if (gotasig = (ourstatus->value.sig = target_signal_from_host (last_sig)))
+ /*last_sig = */ strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
+ gotasig = target_signal_from_host (last_sig);
+ ourstatus->value.sig = gotasig;
+ if (gotasig)
ourstatus->kind = TARGET_WAITKIND_STOPPED;
}
{
case EXCEPTION_ACCESS_VIOLATION:
DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break;
case STATUS_STACK_OVERFLOW:
DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break;
case EXCEPTION_BREAKPOINT:
DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break;
case DBG_CONTROL_C:
DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_INT;
/* User typed CTRL-C. Continue with this status */
last_sig = SIGINT; /* FIXME - should check pass state */
break;
case EXCEPTION_SINGLE_STEP:
DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break;
default:
/* This may be a structured exception handling exception. In
- that case, we want to let the program try to handle it, and
- only break if we see the exception a second time. */
+ that case, we want to let the program try to handle it, and
+ only break if we see the exception a second time. */
if (current_event.u.Exception.dwFirstChance)
return 0;
printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
- current_event.u.Exception.ExceptionRecord.ExceptionCode,
- current_event.u.Exception.ExceptionRecord.ExceptionAddress);
+ current_event.u.Exception.ExceptionRecord.ExceptionCode,
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress);
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
}
DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
current_event.dwProcessId, current_event.dwThreadId));
- if (res = ContinueDebugEvent (current_event.dwProcessId,
- current_event.dwThreadId,
- continue_status))
- for (th = &thread_head; (th = th->next) != NULL; )
+ res = ContinueDebugEvent (current_event.dwProcessId,
+ current_event.dwThreadId,
+ continue_status);
+ if (res)
+ for (th = &thread_head; (th = th->next) != NULL;)
if (((id == -1) || (id == th->id)) && th->suspend_count)
{
for (i = 0; i < th->suspend_count; i++)
while (1)
{
DWORD continue_status;
- BOOL t = WaitForDebugEvent (¤t_event, INFINITE);
+ BOOL debug_event = WaitForDebugEvent (¤t_event, 20);
char *p;
thread_info *th;
int sig;
- event_count++;
+ if (debug_event)
+ {
+ event_count++;
- continue_status = DBG_CONTINUE;
+ continue_status = DBG_CONTINUE;
- switch (current_event.dwDebugEventCode)
- {
- case CREATE_THREAD_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
+ switch (current_event.dwDebugEventCode)
+ {
+ case CREATE_THREAD_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "CREATE_THREAD_DEBUG_EVENT"));
- /* Record the existence of this thread */
- child_add_thread (current_event.dwThreadId,
- current_event.u.CreateThread.hThread);
- if (info_verbose)
- printf_unfiltered ("[New %s]\n",
- target_pid_to_str (current_event.dwThreadId));
- break;
-
- case EXIT_THREAD_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ "CREATE_THREAD_DEBUG_EVENT"));
+ /* Record the existence of this thread */
+ child_add_thread (current_event.dwThreadId,
+ current_event.u.CreateThread.hThread);
+ if (info_verbose)
+ printf_unfiltered ("[New %s]\n",
+ target_pid_to_str (current_event.dwThreadId));
+ break;
+
+ case EXIT_THREAD_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "EXIT_THREAD_DEBUG_EVENT"));
- child_delete_thread (current_event.dwThreadId);
- break;
+ "EXIT_THREAD_DEBUG_EVENT"));
+ child_delete_thread (current_event.dwThreadId);
+ break;
- case CREATE_PROCESS_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ case CREATE_PROCESS_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "CREATE_PROCESS_DEBUG_EVENT"));
- current_process_handle = current_event.u.CreateProcessInfo.hProcess;
+ "CREATE_PROCESS_DEBUG_EVENT"));
+ current_process_handle = current_event.u.CreateProcessInfo.hProcess;
- main_thread_id = inferior_pid = current_event.dwThreadId;
- /* Add the main thread */
- current_thread = child_add_thread (inferior_pid,
- current_event.u.CreateProcessInfo.hThread);
- break;
+ main_thread_id = inferior_pid = current_event.dwThreadId;
+ /* Add the main thread */
+ current_thread = child_add_thread (inferior_pid,
+ current_event.u.CreateProcessInfo.hThread);
+ break;
- case EXIT_PROCESS_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ case EXIT_PROCESS_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "EXIT_PROCESS_DEBUG_EVENT"));
- ourstatus->kind = TARGET_WAITKIND_EXITED;
- ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
- CloseHandle (current_process_handle);
- return current_event.dwProcessId;
- break;
-
- case LOAD_DLL_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ "EXIT_PROCESS_DEBUG_EVENT"));
+ ourstatus->kind = TARGET_WAITKIND_EXITED;
+ ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
+ CloseHandle (current_process_handle);
+ return current_event.dwProcessId;
+ break;
+
+ case LOAD_DLL_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "LOAD_DLL_DEBUG_EVENT"));
- catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
- registers_changed(); /* mark all regs invalid */
- break;
+ "LOAD_DLL_DEBUG_EVENT"));
+ catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
+ registers_changed (); /* mark all regs invalid */
+ break;
- case UNLOAD_DLL_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ case UNLOAD_DLL_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "UNLOAD_DLL_DEBUG_EVENT"));
- break; /* FIXME: don't know what to do here */
+ "UNLOAD_DLL_DEBUG_EVENT"));
+ break; /* FIXME: don't know what to do here */
- case EXCEPTION_DEBUG_EVENT:
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ case EXCEPTION_DEBUG_EVENT:
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "EXCEPTION_DEBUG_EVENT"));
- if (handle_exception (ourstatus))
- return current_event.dwThreadId;
- continue_status = DBG_EXCEPTION_NOT_HANDLED;
- break;
-
- case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
- DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+ "EXCEPTION_DEBUG_EVENT"));
+ if (handle_exception (ourstatus))
+ return current_event.dwThreadId;
+ continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ break;
+
+ case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
+ DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId,
- "OUTPUT_DEBUG_STRING_EVENT"));
- if (handle_output_debug_string (ourstatus))
- return main_thread_id;
- break;
- default:
- printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
- current_event.dwProcessId,
- current_event.dwThreadId);
- printf_unfiltered (" unknown event code %d\n",
- current_event.dwDebugEventCode);
- break;
+ "OUTPUT_DEBUG_STRING_EVENT"));
+ if (handle_output_debug_string (ourstatus))
+ return main_thread_id;
+ break;
+ default:
+ printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
+ current_event.dwProcessId,
+ current_event.dwThreadId);
+ printf_unfiltered (" unknown event code %d\n",
+ current_event.dwDebugEventCode);
+ break;
+ }
+
+ CHECK (child_continue (continue_status, -1));
}
+ else
+ {
+ int detach = 0;
+
+ if (ui_loop_hook != NULL)
+ detach = ui_loop_hook (0);
- CHECK (child_continue (continue_status, -1));
+ if (detach)
+ child_kill_inferior ();
+ }
}
}
char real_path[MAXPATHLEN];
char *winenv;
char *temp;
- int envlen;
+ int envlen;
int i;
STARTUPINFO si;
memset (&si, 0, sizeof (si));
si.cb = sizeof (si);
- cygwin_conv_to_win32_path (exec_file, real_path);
+ cygwin32_conv_to_win32_path (exec_file, real_path);
flags = DEBUG_ONLY_THIS_PROCESS;
to posix style if necessary. */
static const char *conv_path_names[] =
- {
- "PATH=",
- 0
- };
+ {
+ "PATH=",
+ 0
+ };
/* CreateProcess takes the environment list as a null terminated set of
strings (i.e. two nulls terminate the list). */
len = strlen (conv_path_names[j]);
if (strncmp (conv_path_names[j], env[i], len) == 0)
{
- if (cygwin_posix_path_list_p (env[i] + len))
+ if (cygwin32_posix_path_list_p (env[i] + len))
envlen += len
- + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
+ + cygwin32_posix_to_win32_path_list_buf_size (env[i] + len);
else
envlen += strlen (env[i]) + 1;
break;
len = strlen (conv_path_names[j]);
if (strncmp (conv_path_names[j], env[i], len) == 0)
{
- if (cygwin_posix_path_list_p (env[i] + len))
+ if (cygwin32_posix_path_list_p (env[i] + len))
{
memcpy (temp, env[i], len);
- cygwin_posix_to_win32_path_list (env[i] + len, temp + len);
+ cygwin32_posix_to_win32_path_list (env[i] + len, temp + len);
}
else
strcpy (temp, env[i]);
}
ret = CreateProcess (0,
- args, /* command line */
+ args, /* command line */
NULL, /* Security */
NULL, /* thread */
TRUE, /* inherit handles */
&si,
&pi);
if (!ret)
- error ("Error creating process %s, (error %d)\n", exec_file, GetLastError());
+ error ("Error creating process %s, (error %d)\n", exec_file, GetLastError ());
exception_count = 0;
event_count = 0;
/* Ignore the first trap */
child_wait (inferior_pid, &dummy);
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
}
static void
{
DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0));
- registers_changed(); /* refresh register state */
+ registers_changed (); /* refresh register state */
}
int
/* this may fail in an attached process so don't check. */
(void) CloseHandle (current_thread->h);
- target_mourn_inferior(); /* or just child_mourn_inferior? */
+ target_mourn_inferior (); /* or just child_mourn_inferior? */
}
void
int i;
thread_info *th;
DWORD continue_status = last_sig > 0 && last_sig < NSIG ?
- DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
+ DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
pid, step, sig));
DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid));
}
-struct target_ops child_ops ;
+struct target_ops child_ops;
-static void init_child_ops(void)
+static void
+init_child_ops (void)
{
- child_ops.to_shortname = "child";
- child_ops.to_longname = "Win32 child process";
- child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
- child_ops.to_open = child_open;
- child_ops.to_close = child_close;
- child_ops.to_attach = child_attach;
- child_ops.to_detach = child_detach;
- child_ops.to_resume = child_resume;
- child_ops.to_wait = child_wait;
- child_ops.to_fetch_registers = child_fetch_inferior_registers;
- child_ops.to_store_registers = child_store_inferior_registers;
- child_ops.to_prepare_to_store = child_prepare_to_store;
- child_ops.to_xfer_memory = child_xfer_memory;
- child_ops.to_files_info = child_files_info;
- child_ops.to_insert_breakpoint = memory_insert_breakpoint;
- child_ops.to_remove_breakpoint = memory_remove_breakpoint;
- child_ops.to_terminal_init = terminal_init_inferior;
- child_ops.to_terminal_inferior = terminal_inferior;
- child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
- child_ops.to_terminal_ours = terminal_ours;
- child_ops.to_terminal_info = child_terminal_info;
- child_ops.to_kill = child_kill_inferior;
- child_ops.to_load = 0;
- child_ops.to_lookup_symbol = 0;
- child_ops.to_create_inferior = child_create_inferior;
- child_ops.to_mourn_inferior = child_mourn_inferior;
- child_ops.to_can_run = child_can_run;
- child_ops.to_notice_signals = 0;
- child_ops.to_thread_alive = child_thread_alive;
- child_ops.to_stop = child_stop;
- child_ops.to_stratum = process_stratum;
- child_ops.DONT_USE = 0;
- child_ops.to_has_all_memory = 1;
- child_ops.to_has_memory = 1;
- child_ops.to_has_stack = 1;
- child_ops.to_has_registers = 1;
- child_ops.to_has_execution = 1;
- child_ops.to_sections = 0;
- child_ops.to_sections_end = 0;
- child_ops.to_magic = OPS_MAGIC;
+ child_ops.to_shortname = "child";
+ child_ops.to_longname = "Win32 child process";
+ child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
+ child_ops.to_open = child_open;
+ child_ops.to_close = child_close;
+ child_ops.to_attach = child_attach;
+ child_ops.to_detach = child_detach;
+ child_ops.to_resume = child_resume;
+ child_ops.to_wait = child_wait;
+ child_ops.to_fetch_registers = child_fetch_inferior_registers;
+ child_ops.to_store_registers = child_store_inferior_registers;
+ child_ops.to_prepare_to_store = child_prepare_to_store;
+ child_ops.to_xfer_memory = child_xfer_memory;
+ child_ops.to_files_info = child_files_info;
+ child_ops.to_insert_breakpoint = memory_insert_breakpoint;
+ child_ops.to_remove_breakpoint = memory_remove_breakpoint;
+ child_ops.to_terminal_init = terminal_init_inferior;
+ child_ops.to_terminal_inferior = terminal_inferior;
+ child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
+ child_ops.to_terminal_ours = terminal_ours;
+ child_ops.to_terminal_info = child_terminal_info;
+ child_ops.to_kill = child_kill_inferior;
+ child_ops.to_load = 0;
+ child_ops.to_lookup_symbol = 0;
+ child_ops.to_create_inferior = child_create_inferior;
+ child_ops.to_mourn_inferior = child_mourn_inferior;
+ child_ops.to_can_run = child_can_run;
+ child_ops.to_notice_signals = 0;
+ child_ops.to_thread_alive = win32_child_thread_alive;
+ child_ops.to_stop = child_stop;
+ child_ops.to_stratum = process_stratum;
+ child_ops.DONT_USE = 0;
+ child_ops.to_has_all_memory = 1;
+ child_ops.to_has_memory = 1;
+ child_ops.to_has_stack = 1;
+ child_ops.to_has_registers = 1;
+ child_ops.to_has_execution = 1;
+ child_ops.to_sections = 0;
+ child_ops.to_sections_end = 0;
+ child_ops.to_magic = OPS_MAGIC;
}
void
_initialize_inftarg ()
{
struct cmd_list_element *c;
- init_child_ops() ;
+ init_child_ops ();
add_show_from_set
(add_set_cmd ("new-console", class_support, var_boolean,
add_show_from_set
(add_set_cmd ("debugexceptions", class_support, var_boolean,
(char *) &debug_exceptions,
- "Set whether to display kernel exceptions in child process.",
+ "Set whether to display kernel exceptions in child process.",
&setlist),
&showlist);
by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
it means that the pid has died. Otherwise it is assumed to be alive. */
static int
-child_thread_alive (int pid)
+win32_child_thread_alive (int pid)
{
- return WaitForSingleObject(thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
- FALSE : TRUE;
+ return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
+ FALSE : TRUE;
}
/* Convert pid to printable format. */