OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

import gdb-1999-07-07 post reformat

This commit is contained in:
Jason Molenda 1999-07-07 20:11:14 +00:00
parent 103186c62b
commit 3a4b77d8be
1 changed files with 146 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

288
gdb/windows-nat.c
View File

@ -16,8 +16,9 @@
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software 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 */ /* by Steve Chamberlain, sac@cygnus.com */
@ -84,16 +85,18 @@ static int last_sig = 0; /* Set if a signal was received from the
/* Thread information structure used to track information that is /* Thread information structure used to track information that is
not available in gdb's thread structure. */ not available in gdb's thread structure. */
typedef struct thread_info_struct typedef struct thread_info_struct
{ {
struct thread_info_struct *next; struct thread_info_struct *next;
DWORD id; DWORD id;
HANDLE h; HANDLE h;
char *name; char *name;
int suspend_count; int suspend_count;
CONTEXT context; CONTEXT context;
} thread_info; }
thread_info;
static thread_info thread_head = {NULL}; static thread_info thread_head =
{NULL};
/* The process and thread handles for the above context. */ /* The process and thread handles for the above context. */
@ -101,7 +104,7 @@ static DEBUG_EVENT current_event; /* The current debug event from
WaitForDebugEvent */ WaitForDebugEvent */
static HANDLE current_process_handle; /* Currently executing process */ static HANDLE current_process_handle; /* Currently executing process */
static thread_info *current_thread; /* Info on currently selected thread */ 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. */ /* Counts of things. */
static int exception_count = 0; static int exception_count = 0;
@ -110,9 +113,9 @@ static int event_count = 0;
/* User options. */ /* User options. */
static int new_console = 0; static int new_console = 0;
static int new_group = 0; static int new_group = 0;
static int debug_exec = 0; /* show execution */ static int debug_exec = 0; /* show execution */
static int debug_events = 0; /* show events from kernel */ static int debug_events = 0; /* show events from kernel */
static int debug_memory = 0; /* show target memory accesses */ static int debug_memory = 0; /* show target memory accesses */
static int debug_exceptions = 0; /* show target exceptions */ static int debug_exceptions = 0; /* show target exceptions */
/* This vector maps GDB's idea of a register's number into an address /* This vector maps GDB's idea of a register's number into an address
@ -131,30 +134,30 @@ static int debug_exceptions = 0; /* show target exceptions */
#define context_offset(x) ((int)&(((CONTEXT *)NULL)->x)) #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
static const int mappings[] = static const int mappings[] =
{ {
context_offset(Eax), context_offset (Eax),
context_offset(Ecx), context_offset (Ecx),
context_offset(Edx), context_offset (Edx),
context_offset(Ebx), context_offset (Ebx),
context_offset(Esp), context_offset (Esp),
context_offset(Ebp), context_offset (Ebp),
context_offset(Esi), context_offset (Esi),
context_offset(Edi), context_offset (Edi),
context_offset(Eip), context_offset (Eip),
context_offset(EFlags), context_offset (EFlags),
context_offset(SegCs), context_offset (SegCs),
context_offset(SegSs), context_offset (SegSs),
context_offset(SegDs), context_offset (SegDs),
context_offset(SegEs), context_offset (SegEs),
context_offset(SegFs), context_offset (SegFs),
context_offset(SegGs), context_offset (SegGs),
context_offset(FloatSave.RegisterArea[0 * 10]), context_offset (FloatSave.RegisterArea[0 * 10]),
context_offset(FloatSave.RegisterArea[1 * 10]), context_offset (FloatSave.RegisterArea[1 * 10]),
context_offset(FloatSave.RegisterArea[2 * 10]), context_offset (FloatSave.RegisterArea[2 * 10]),
context_offset(FloatSave.RegisterArea[3 * 10]), context_offset (FloatSave.RegisterArea[3 * 10]),
context_offset(FloatSave.RegisterArea[4 * 10]), context_offset (FloatSave.RegisterArea[4 * 10]),
context_offset(FloatSave.RegisterArea[5 * 10]), context_offset (FloatSave.RegisterArea[5 * 10]),
context_offset(FloatSave.RegisterArea[6 * 10]), context_offset (FloatSave.RegisterArea[6 * 10]),
context_offset(FloatSave.RegisterArea[7 * 10]), context_offset (FloatSave.RegisterArea[7 * 10]),
}; };
/* This vector maps the target's idea of an exception (extracted /* This vector maps the target's idea of an exception (extracted
@ -184,7 +187,7 @@ thread_rec (DWORD id, int get_context)
{ {
thread_info *th; 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->id == id)
{ {
if (!th->suspend_count && get_context) if (!th->suspend_count && get_context)
@ -205,7 +208,7 @@ thread_rec (DWORD id, int get_context)
/* Add a thread to the thread list */ /* Add a thread to the thread list */
static thread_info * static thread_info *
child_add_thread(DWORD id, HANDLE h) child_add_thread (DWORD id, HANDLE h)
{ {
thread_info *th; thread_info *th;
@ -213,7 +216,7 @@ child_add_thread(DWORD id, HANDLE h)
return th; return th;
th = (thread_info *) xmalloc (sizeof (*th)); th = (thread_info *) xmalloc (sizeof (*th));
memset(th, 0, sizeof (*th)); memset (th, 0, sizeof (*th));
th->id = id; th->id = id;
th->h = h; th->h = h;
th->next = thread_head.next; th->next = thread_head.next;
@ -316,7 +319,7 @@ child_store_inferior_registers (int r)
static int static int
handle_load_dll (PTR dummy) handle_load_dll (PTR dummy)
{ {
LOAD_DLL_DEBUG_INFO * event = &current_event.u.LoadDll; LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
DWORD dll_name_ptr; DWORD dll_name_ptr;
DWORD done; DWORD done;
char dll_buf[MAX_PATH + 1]; char dll_buf[MAX_PATH + 1];
@ -324,7 +327,7 @@ handle_load_dll (PTR dummy)
struct objfile *objfile; struct objfile *objfile;
MEMORY_BASIC_INFORMATION minfo; MEMORY_BASIC_INFORMATION minfo;
dll_buf[0] = dll_buf[sizeof(dll_buf) - 1] = '\0'; dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
/* The following code attempts to find the name of the dll by reading the /* 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. name from the processes memory. Unfortunately it doesn't work right.
@ -332,7 +335,8 @@ handle_load_dll (PTR dummy)
#ifdef DOESNT_WORK #ifdef DOESNT_WORK
memset (&minfo, 0, sizeof minfo); memset (&minfo, 0, sizeof minfo);
if (VirtualQueryEx (current_process_handle, (LPCVOID) event->lpBaseOfDll, if (VirtualQueryEx (current_process_handle, (LPCVOID) event->lpBaseOfDll,
&minfo, sizeof(minfo)) && minfo.BaseAddress) { &minfo, sizeof (minfo)) && minfo.BaseAddress)
{
DWORD len; DWORD len;
IMAGE_DOS_HEADER *hmm0 = (IMAGE_DOS_HEADER *) minfo.BaseAddress; IMAGE_DOS_HEADER *hmm0 = (IMAGE_DOS_HEADER *) minfo.BaseAddress;
HMODULE hmm = (HMODULE) (((DWORD) hmm0) + hmm0->e_lfanew); HMODULE hmm = (HMODULE) (((DWORD) hmm0) + hmm0->e_lfanew);
@ -342,7 +346,7 @@ handle_load_dll (PTR dummy)
dll_name = dll_buf; dll_name = dll_buf;
dll_name[len] = '\0'; dll_name[len] = '\0';
} }
} }
#endif #endif
/* Attempt to read the name of the dll that was detected. /* Attempt to read the name of the dll that was detected.
@ -360,7 +364,7 @@ handle_load_dll (PTR dummy)
sizeof (dll_name_ptr), &done); sizeof (dll_name_ptr), &done);
/* See if we could read the address of a string, and that the /* 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) if (done != sizeof (dll_name_ptr) || !dll_name_ptr)
return 1; return 1;
@ -410,23 +414,23 @@ handle_load_dll (PTR dummy)
/* FIXME!! It would be nice to define one symbol which pointed to the /* FIXME!! It would be nice to define one symbol which pointed to the
front of the dll if we can't find any symbols. */ front of the dll if we can't find any symbols. */
if (!(dll_basename = strrchr(dll_name, '/'))) if (!(dll_basename = strrchr (dll_name, '/')))
dll_basename = dll_name; dll_basename = dll_name;
else else
dll_basename++; dll_basename++;
ALL_OBJFILES(objfile) ALL_OBJFILES (objfile)
{ {
char *objfile_basename; char *objfile_basename;
objfile_basename = strrchr(objfile->name, '/'); objfile_basename = strrchr (objfile->name, '/');
if (objfile_basename && if (objfile_basename &&
strcmp(dll_basename, objfile_basename + 1) == 0) strcmp (dll_basename, objfile_basename + 1) == 0)
{ {
printf_unfiltered ("%x:%s (symbols previously loaded)\n", printf_unfiltered ("%x:%s (symbols previously loaded)\n",
event->lpBaseOfDll, dll_name); event->lpBaseOfDll, dll_name);
goto out; goto out;
} }
} }
/* The symbols in a dll are offset by 0x1000, which is the /* The symbols in a dll are offset by 0x1000, which is the
@ -453,18 +457,18 @@ handle_output_debug_string (struct target_waitstatus *ourstatus)
int gotasig = FALSE; int gotasig = FALSE;
if (!target_read_string 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) || !s || !*s)
return gotasig; 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); warning (s);
} }
else else
{ {
char *p; char *p;
/*last_sig = */strtol(s + sizeof(CYGWIN_SIGNAL_STRING) - 1, &p, 0); /*last_sig = */ strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
gotasig = target_signal_from_host (last_sig); gotasig = target_signal_from_host (last_sig);
ourstatus->value.sig = gotasig; ourstatus->value.sig = gotasig;
if (gotasig) if (gotasig)
@ -491,41 +495,41 @@ handle_exception (struct target_waitstatus *ourstatus)
{ {
case EXCEPTION_ACCESS_VIOLATION: case EXCEPTION_ACCESS_VIOLATION:
DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n", 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; ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break; break;
case STATUS_STACK_OVERFLOW: case STATUS_STACK_OVERFLOW:
DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n", 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; ourstatus->value.sig = TARGET_SIGNAL_SEGV;
break; break;
case EXCEPTION_BREAKPOINT: case EXCEPTION_BREAKPOINT:
DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n", 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; ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break; break;
case DBG_CONTROL_C: case DBG_CONTROL_C:
DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n", 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; ourstatus->value.sig = TARGET_SIGNAL_INT;
/* User typed CTRL-C. Continue with this status */ /* User typed CTRL-C. Continue with this status */
last_sig = SIGINT; /* FIXME - should check pass state */ last_sig = SIGINT; /* FIXME - should check pass state */
break; break;
case EXCEPTION_SINGLE_STEP: case EXCEPTION_SINGLE_STEP:
DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n", 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; ourstatus->value.sig = TARGET_SIGNAL_TRAP;
break; break;
default: default:
/* This may be a structured exception handling exception. In /* This may be a structured exception handling exception. In
that case, we want to let the program try to handle it, and that case, we want to let the program try to handle it, and
only break if we see the exception a second time. */ only break if we see the exception a second time. */
if (current_event.u.Exception.dwFirstChance) if (current_event.u.Exception.dwFirstChance)
return 0; return 0;
printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n", printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
current_event.u.Exception.ExceptionRecord.ExceptionCode, current_event.u.Exception.ExceptionRecord.ExceptionCode,
current_event.u.Exception.ExceptionRecord.ExceptionAddress); current_event.u.Exception.ExceptionRecord.ExceptionAddress);
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
break; break;
} }
@ -548,7 +552,7 @@ child_continue (DWORD continue_status, int id)
current_event.dwThreadId, current_event.dwThreadId,
continue_status); continue_status);
if (res) if (res)
for (th = &thread_head; (th = th->next) != NULL; ) for (th = &thread_head; (th = th->next) != NULL;)
if (((id == -1) || (id == th->id)) && th->suspend_count) if (((id == -1) || (id == th->id)) && th->suspend_count)
{ {
for (i = 0; i < th->suspend_count; i++) for (i = 0; i < th->suspend_count; i++)
@ -586,38 +590,38 @@ child_wait (int pid, struct target_waitstatus *ourstatus)
{ {
case CREATE_THREAD_DEBUG_EVENT: case CREATE_THREAD_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"CREATE_THREAD_DEBUG_EVENT")); "CREATE_THREAD_DEBUG_EVENT"));
/* Record the existence of this thread */ /* Record the existence of this thread */
child_add_thread (current_event.dwThreadId, child_add_thread (current_event.dwThreadId,
current_event.u.CreateThread.hThread); current_event.u.CreateThread.hThread);
if (info_verbose) if (info_verbose)
printf_unfiltered ("[New %s]\n", printf_unfiltered ("[New %s]\n",
target_pid_to_str (current_event.dwThreadId)); target_pid_to_str (current_event.dwThreadId));
break; break;
case EXIT_THREAD_DEBUG_EVENT: case EXIT_THREAD_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"EXIT_THREAD_DEBUG_EVENT")); "EXIT_THREAD_DEBUG_EVENT"));
child_delete_thread (current_event.dwThreadId); child_delete_thread (current_event.dwThreadId);
break; break;
case CREATE_PROCESS_DEBUG_EVENT: case CREATE_PROCESS_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"CREATE_PROCESS_DEBUG_EVENT")); "CREATE_PROCESS_DEBUG_EVENT"));
current_process_handle = current_event.u.CreateProcessInfo.hProcess; current_process_handle = current_event.u.CreateProcessInfo.hProcess;
main_thread_id = inferior_pid = current_event.dwThreadId; main_thread_id = inferior_pid = current_event.dwThreadId;
/* Add the main thread */ /* Add the main thread */
current_thread = child_add_thread (inferior_pid, current_thread = child_add_thread (inferior_pid,
current_event.u.CreateProcessInfo.hThread); current_event.u.CreateProcessInfo.hThread);
break; break;
case EXIT_PROCESS_DEBUG_EVENT: case EXIT_PROCESS_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"EXIT_PROCESS_DEBUG_EVENT")); "EXIT_PROCESS_DEBUG_EVENT"));
ourstatus->kind = TARGET_WAITKIND_EXITED; ourstatus->kind = TARGET_WAITKIND_EXITED;
ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode; ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
@ -627,30 +631,30 @@ child_wait (int pid, struct target_waitstatus *ourstatus)
case LOAD_DLL_DEBUG_EVENT: case LOAD_DLL_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"LOAD_DLL_DEBUG_EVENT")); "LOAD_DLL_DEBUG_EVENT"));
catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL); catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
registers_changed(); /* mark all regs invalid */ registers_changed (); /* mark all regs invalid */
break; break;
case UNLOAD_DLL_DEBUG_EVENT: case UNLOAD_DLL_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"UNLOAD_DLL_DEBUG_EVENT")); "UNLOAD_DLL_DEBUG_EVENT"));
break; /* FIXME: don't know what to do here */ break; /* FIXME: don't know what to do here */
case EXCEPTION_DEBUG_EVENT: case EXCEPTION_DEBUG_EVENT:
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"EXCEPTION_DEBUG_EVENT")); "EXCEPTION_DEBUG_EVENT"));
if (handle_exception (ourstatus)) if (handle_exception (ourstatus))
return current_event.dwThreadId; return current_event.dwThreadId;
continue_status = DBG_EXCEPTION_NOT_HANDLED; continue_status = DBG_EXCEPTION_NOT_HANDLED;
break; break;
case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */ case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n", DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
current_event.dwProcessId, current_event.dwThreadId, current_event.dwProcessId, current_event.dwThreadId,
"OUTPUT_DEBUG_STRING_EVENT")); "OUTPUT_DEBUG_STRING_EVENT"));
if (handle_output_debug_string (ourstatus)) if (handle_output_debug_string (ourstatus))
return main_thread_id; return main_thread_id;
@ -769,7 +773,7 @@ child_create_inferior (exec_file, allargs, env)
char real_path[MAXPATHLEN]; char real_path[MAXPATHLEN];
char *winenv; char *winenv;
char *temp; char *temp;
int envlen; int envlen;
int i; int i;
STARTUPINFO si; STARTUPINFO si;
@ -815,10 +819,10 @@ child_create_inferior (exec_file, allargs, env)
to posix style if necessary. */ to posix style if necessary. */
static const char *conv_path_names[] = static const char *conv_path_names[] =
{ {
"PATH=", "PATH=",
0 0
}; };
/* CreateProcess takes the environment list as a null terminated set of /* CreateProcess takes the environment list as a null terminated set of
strings (i.e. two nulls terminate the list). */ strings (i.e. two nulls terminate the list). */
@ -878,7 +882,7 @@ child_create_inferior (exec_file, allargs, env)
} }
ret = CreateProcess (0, ret = CreateProcess (0,
args, /* command line */ args, /* command line */
NULL, /* Security */ NULL, /* Security */
NULL, /* thread */ NULL, /* thread */
TRUE, /* inherit handles */ TRUE, /* inherit handles */
@ -888,7 +892,7 @@ child_create_inferior (exec_file, allargs, env)
&si, &si,
&pi); &pi);
if (!ret) 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; exception_count = 0;
event_count = 0; event_count = 0;
@ -926,7 +930,7 @@ child_stop ()
{ {
DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n")); DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0)); CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0));
registers_changed(); /* refresh register state */ registers_changed (); /* refresh register state */
} }
int int
@ -971,7 +975,7 @@ child_kill_inferior (void)
/* this may fail in an attached process so don't check. */ /* this may fail in an attached process so don't check. */
(void) CloseHandle (current_thread->h); (void) CloseHandle (current_thread->h);
target_mourn_inferior(); /* or just child_mourn_inferior? */ target_mourn_inferior (); /* or just child_mourn_inferior? */
} }
void void
@ -980,7 +984,7 @@ child_resume (int pid, int step, enum target_signal sig)
int i; int i;
thread_info *th; thread_info *th;
DWORD continue_status = last_sig > 0 && last_sig < NSIG ? 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", DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
pid, step, sig)); pid, step, sig));
@ -1029,58 +1033,58 @@ child_close ()
DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid)); DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid));
} }
struct target_ops child_ops ; struct target_ops child_ops;
static void static void
init_child_ops(void) init_child_ops (void)
{ {
child_ops.to_shortname = "child"; child_ops.to_shortname = "child";
child_ops.to_longname = "Win32 child process"; child_ops.to_longname = "Win32 child process";
child_ops.to_doc = "Win32 child process (started by the \"run\" command)."; child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
child_ops.to_open = child_open; child_ops.to_open = child_open;
child_ops.to_close = child_close; child_ops.to_close = child_close;
child_ops.to_attach = child_attach; child_ops.to_attach = child_attach;
child_ops.to_detach = child_detach; child_ops.to_detach = child_detach;
child_ops.to_resume = child_resume; child_ops.to_resume = child_resume;
child_ops.to_wait = child_wait; child_ops.to_wait = child_wait;
child_ops.to_fetch_registers = child_fetch_inferior_registers; child_ops.to_fetch_registers = child_fetch_inferior_registers;
child_ops.to_store_registers = child_store_inferior_registers; child_ops.to_store_registers = child_store_inferior_registers;
child_ops.to_prepare_to_store = child_prepare_to_store; child_ops.to_prepare_to_store = child_prepare_to_store;
child_ops.to_xfer_memory = child_xfer_memory; child_ops.to_xfer_memory = child_xfer_memory;
child_ops.to_files_info = child_files_info; child_ops.to_files_info = child_files_info;
child_ops.to_insert_breakpoint = memory_insert_breakpoint; child_ops.to_insert_breakpoint = memory_insert_breakpoint;
child_ops.to_remove_breakpoint = memory_remove_breakpoint; child_ops.to_remove_breakpoint = memory_remove_breakpoint;
child_ops.to_terminal_init = terminal_init_inferior; child_ops.to_terminal_init = terminal_init_inferior;
child_ops.to_terminal_inferior = terminal_inferior; child_ops.to_terminal_inferior = terminal_inferior;
child_ops.to_terminal_ours_for_output = terminal_ours_for_output; child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
child_ops.to_terminal_ours = terminal_ours; child_ops.to_terminal_ours = terminal_ours;
child_ops.to_terminal_info = child_terminal_info; child_ops.to_terminal_info = child_terminal_info;
child_ops.to_kill = child_kill_inferior; child_ops.to_kill = child_kill_inferior;
child_ops.to_load = 0; child_ops.to_load = 0;
child_ops.to_lookup_symbol = 0; child_ops.to_lookup_symbol = 0;
child_ops.to_create_inferior = child_create_inferior; child_ops.to_create_inferior = child_create_inferior;
child_ops.to_mourn_inferior = child_mourn_inferior; child_ops.to_mourn_inferior = child_mourn_inferior;
child_ops.to_can_run = child_can_run; child_ops.to_can_run = child_can_run;
child_ops.to_notice_signals = 0; child_ops.to_notice_signals = 0;
child_ops.to_thread_alive = win32_child_thread_alive; child_ops.to_thread_alive = win32_child_thread_alive;
child_ops.to_stop = child_stop; child_ops.to_stop = child_stop;
child_ops.to_stratum = process_stratum; child_ops.to_stratum = process_stratum;
child_ops.DONT_USE = 0; child_ops.DONT_USE = 0;
child_ops.to_has_all_memory = 1; child_ops.to_has_all_memory = 1;
child_ops.to_has_memory = 1; child_ops.to_has_memory = 1;
child_ops.to_has_stack = 1; child_ops.to_has_stack = 1;
child_ops.to_has_registers = 1; child_ops.to_has_registers = 1;
child_ops.to_has_execution = 1; child_ops.to_has_execution = 1;
child_ops.to_sections = 0; child_ops.to_sections = 0;
child_ops.to_sections_end = 0; child_ops.to_sections_end = 0;
child_ops.to_magic = OPS_MAGIC; child_ops.to_magic = OPS_MAGIC;
} }
void void
_initialize_inftarg () _initialize_inftarg ()
{ {
struct cmd_list_element *c; struct cmd_list_element *c;
init_child_ops() ; init_child_ops ();
add_show_from_set add_show_from_set
(add_set_cmd ("new-console", class_support, var_boolean, (add_set_cmd ("new-console", class_support, var_boolean,
@ -1120,7 +1124,7 @@ _initialize_inftarg ()
add_show_from_set add_show_from_set
(add_set_cmd ("debugexceptions", class_support, var_boolean, (add_set_cmd ("debugexceptions", class_support, var_boolean,
(char *) &debug_exceptions, (char *) &debug_exceptions,
"Set whether to display kernel exceptions in child process.", "Set whether to display kernel exceptions in child process.",
&setlist), &setlist),
&showlist); &showlist);
@ -1133,8 +1137,8 @@ _initialize_inftarg ()
static int static int
win32_child_thread_alive (int pid) win32_child_thread_alive (int pid)
{ {
return WaitForSingleObject(thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ? return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
FALSE : TRUE; FALSE : TRUE;
} }
/* Convert pid to printable format. */ /* Convert pid to printable format. */