URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [win32-nat.c] - Diff between revs 1181 and 1765

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 1181	Rev 1765
`/* Target-vector operations for controlling win32 child processes, for GDB.`	`/* Target-vector operations for controlling win32 child processes, for GDB.`

`Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free`	`Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free`
`Software Foundation, Inc.`	`Software Foundation, Inc.`

`Contributed by Cygnus Solutions, A Red Hat Company.`	`Contributed by Cygnus Solutions, A Red Hat Company.`

`This file is part of GDB.`	`This file is part of GDB.`

`This program is free software; you can redistribute it and/or modify`	`This program is free software; you can redistribute it and/or modify`
`it under the terms of the GNU General Public License as published by`	`it under the terms of the GNU General Public License as published by`
`the Free Software Foundation; either version 2 of the License, or`	`the Free Software Foundation; either version 2 of the License, or`
`(at your option) any later version.`	`(at your option) any later version.`

`This program is distributed in the hope that it will be useful,`	`This program is distributed in the hope that it will be useful,`
`but WITHOUT ANY WARRANTY; without eve nthe implied warranty of`	`but WITHOUT ANY WARRANTY; without eve nthe implied warranty of`
`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
`GNU General Public License for more details.`	`GNU General Public License for more details.`

`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,`	`Foundation, Inc., 59 Temple Place - Suite 330,`
`Boston, MA 02111-1307, USA. */`	`Boston, MA 02111-1307, USA. */`

`/* Originally by Steve Chamberlain, sac@cygnus.com */`	`/* Originally by Steve Chamberlain, sac@cygnus.com */`

`/* We assume we're being built with and will be used for cygwin. */`	`/* We assume we're being built with and will be used for cygwin. */`

`#include "defs.h"`	`#include "defs.h"`
`#include "tm.h" /* required for SSE registers */`	`#include "tm.h" /* required for SSE registers */`
`#include "frame.h" /* required by inferior.h */`	`#include "frame.h" /* required by inferior.h */`
`#include "inferior.h"`	`#include "inferior.h"`
`#include "target.h"`	`#include "target.h"`
`#include "gdbcore.h"`	`#include "gdbcore.h"`
`#include "command.h"`	`#include "command.h"`
`#include "completer.h"`	`#include "completer.h"`
`#include "regcache.h"`	`#include "regcache.h"`
`#include "top.h"`	`#include "top.h"`
`#include "i386-tdep.h"`	`#include "i386-tdep.h"`
`#include <signal.h>`	`#include <signal.h>`
`#include <sys/types.h>`	`#include <sys/types.h>`
`#include <fcntl.h>`	`#include <fcntl.h>`
`#include <stdlib.h>`	`#include <stdlib.h>`
`#include <windows.h>`	`#include <windows.h>`
`#include <imagehlp.h>`	`#include <imagehlp.h>`
`#include <sys/cygwin.h>`	`#include <sys/cygwin.h>`

`#include "buildsym.h"`	`#include "buildsym.h"`
`#include "symfile.h"`	`#include "symfile.h"`
`#include "objfiles.h"`	`#include "objfiles.h"`
`#include "gdb_string.h"`	`#include "gdb_string.h"`
`#include "gdbthread.h"`	`#include "gdbthread.h"`
`#include "gdbcmd.h"`	`#include "gdbcmd.h"`
`#include <sys/param.h>`	`#include <sys/param.h>`
`#include <unistd.h>`	`#include <unistd.h>`

`/* The ui's event loop. */`	`/* The ui's event loop. */`
`extern int (*ui_loop_hook) (int signo);`	`extern int (*ui_loop_hook) (int signo);`

`/* If we're not using the old Cygwin header file set, define the`	`/* If we're not using the old Cygwin header file set, define the`
`following which never should have been in the generic Win32 API`	`following which never should have been in the generic Win32 API`
`headers in the first place since they were our own invention... */`	`headers in the first place since they were our own invention... */`
`#ifndef _GNU_H_WINDOWS_H`	`#ifndef _GNU_H_WINDOWS_H`
`enum`	`enum`
`{`	`{`
`FLAG_TRACE_BIT = 0x100,`	`FLAG_TRACE_BIT = 0x100,`
`CONTEXT_DEBUGGER = (CONTEXT_FULL \| CONTEXT_FLOATING_POINT)`	`CONTEXT_DEBUGGER = (CONTEXT_FULL \| CONTEXT_FLOATING_POINT)`
`};`	`};`
`#endif`	`#endif`
`#include <sys/procfs.h>`	`#include <sys/procfs.h>`
`#include <psapi.h>`	`#include <psapi.h>`

`#ifdef HAVE_SSE_REGS`	`#ifdef HAVE_SSE_REGS`
`#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER \| CONTEXT_DEBUG_REGISTERS \`	`#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER \| CONTEXT_DEBUG_REGISTERS \`
`\| CONTEXT_EXTENDED_REGISTERS`	`\| CONTEXT_EXTENDED_REGISTERS`
`#else`	`#else`
`#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER \| CONTEXT_DEBUG_REGISTERS`	`#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER \| CONTEXT_DEBUG_REGISTERS`
`#endif`	`#endif`

`static unsigned dr[8];`	`static unsigned dr[8];`
`static int debug_registers_changed = 0;`	`static int debug_registers_changed = 0;`
`static int debug_registers_used = 0;`	`static int debug_registers_used = 0;`

`/* The string sent by cygwin when it processes a signal.`	`/* The string sent by cygwin when it processes a signal.`
`FIXME: This should be in a cygwin include file. */`	`FIXME: This should be in a cygwin include file. */`
`#define CYGWIN_SIGNAL_STRING "cygwin: signal"`	`#define CYGWIN_SIGNAL_STRING "cygwin: signal"`

`#define CHECK(x) check (x, __FILE__,__LINE__)`	`#define CHECK(x) check (x, __FILE__,__LINE__)`
`#define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x`	`#define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x`
`#define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x`	`#define DEBUG_EVENTS(x) if (debug_events) printf_unfiltered x`
`#define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x`	`#define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x`
`#define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x`	`#define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x`

`/* Forward declaration */`	`/* Forward declaration */`
`extern struct target_ops child_ops;`	`extern struct target_ops child_ops;`

`static void child_stop (void);`	`static void child_stop (void);`
`static int win32_child_thread_alive (ptid_t);`	`static int win32_child_thread_alive (ptid_t);`
`void child_kill_inferior (void);`	`void child_kill_inferior (void);`

`static enum target_signal last_sig = TARGET_SIGNAL_0;`	`static enum target_signal last_sig = TARGET_SIGNAL_0;`
`/* Set if a signal was received from the debugged process */`	`/* Set if a signal was received from the debugged process */`

`/* 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;`
`STACKFRAME sf;`	`STACKFRAME sf;`
`}`	`}`
`thread_info;`	`thread_info;`

`static thread_info thread_head;`	`static thread_info thread_head;`

`/* The process and thread handles for the above context. */`	`/* The process and thread handles for the above context. */`

`static DEBUG_EVENT current_event; /* The current debug event from`	`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 */`
`static pid_t cygwin_pid; /* pid of cygwin process */`	`static pid_t cygwin_pid; /* pid of cygwin process */`

`/* Counts of things. */`	`/* Counts of things. */`
`static int exception_count = 0;`	`static int exception_count = 0;`
`static int event_count = 0;`	`static int event_count = 0;`
`static int saw_create;`	`static int saw_create;`

`/* User options. */`	`/* User options. */`
`static int new_console = 0;`	`static int new_console = 0;`
`static int new_group = 1;`	`static int new_group = 1;`
`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 */`
`static int useshell = 0; /* use shell for subprocesses */`	`static int useshell = 0; /* use shell for subprocesses */`

`/* 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`
`in the win32 exception context vector.`	`in the win32 exception context vector.`

`It also contains the bit mask needed to load the register in question.`	`It also contains the bit mask needed to load the register in question.`

`One day we could read a reg, we could inspect the context we`	`One day we could read a reg, we could inspect the context we`
`already have loaded, if it doesn't have the bit set that we need,`	`already have loaded, if it doesn't have the bit set that we need,`
`we read that set of registers in using GetThreadContext. If the`	`we read that set of registers in using GetThreadContext. If the`
`context already contains what we need, we just unpack it. Then to`	`context already contains what we need, we just unpack it. Then to`
`write a register, first we have to ensure that the context contains`	`write a register, first we have to ensure that the context contains`
`the other regs of the group, and then we copy the info in and set`	`the other regs of the group, and then we copy the info in and set`
`out bit. */`	`out bit. */`

`#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]),`
`context_offset (FloatSave.ControlWord),`	`context_offset (FloatSave.ControlWord),`
`context_offset (FloatSave.StatusWord),`	`context_offset (FloatSave.StatusWord),`
`context_offset (FloatSave.TagWord),`	`context_offset (FloatSave.TagWord),`
`context_offset (FloatSave.ErrorSelector),`	`context_offset (FloatSave.ErrorSelector),`
`context_offset (FloatSave.ErrorOffset),`	`context_offset (FloatSave.ErrorOffset),`
`context_offset (FloatSave.DataSelector),`	`context_offset (FloatSave.DataSelector),`
`context_offset (FloatSave.DataOffset),`	`context_offset (FloatSave.DataOffset),`
`context_offset (FloatSave.ErrorSelector)`	`context_offset (FloatSave.ErrorSelector)`
`#ifdef HAVE_SSE_REGS`	`#ifdef HAVE_SSE_REGS`
`/* XMM0-7 */ ,`	`/* XMM0-7 */ ,`
`context_offset (ExtendedRegisters[10*16]),`	`context_offset (ExtendedRegisters[10*16]),`
`context_offset (ExtendedRegisters[11*16]),`	`context_offset (ExtendedRegisters[11*16]),`
`context_offset (ExtendedRegisters[12*16]),`	`context_offset (ExtendedRegisters[12*16]),`
`context_offset (ExtendedRegisters[13*16]),`	`context_offset (ExtendedRegisters[13*16]),`
`context_offset (ExtendedRegisters[14*16]),`	`context_offset (ExtendedRegisters[14*16]),`
`context_offset (ExtendedRegisters[15*16]),`	`context_offset (ExtendedRegisters[15*16]),`
`context_offset (ExtendedRegisters[16*16]),`	`context_offset (ExtendedRegisters[16*16]),`
`context_offset (ExtendedRegisters[17*16]),`	`context_offset (ExtendedRegisters[17*16]),`
`/* MXCSR */`	`/* MXCSR */`
`context_offset (ExtendedRegisters[24])`	`context_offset (ExtendedRegisters[24])`
`#endif`	`#endif`
`};`	`};`

`#undef context_offset`	`#undef context_offset`

`/* This vector maps the target's idea of an exception (extracted`	`/* This vector maps the target's idea of an exception (extracted`
`from the DEBUG_EVENT structure) to GDB's idea. */`	`from the DEBUG_EVENT structure) to GDB's idea. */`

`struct xlate_exception`	`struct xlate_exception`
`{`	`{`
`int them;`	`int them;`
`enum target_signal us;`	`enum target_signal us;`
`};`	`};`

`static const struct xlate_exception`	`static const struct xlate_exception`
`xlate[] =`	`xlate[] =`
`{`	`{`
`{EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},`	`{EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},`
`{STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},`	`{STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},`
`{EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},`	`{EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},`
`{DBG_CONTROL_C, TARGET_SIGNAL_INT},`	`{DBG_CONTROL_C, TARGET_SIGNAL_INT},`
`{EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},`	`{EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},`
`{STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},`	`{STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},`
`{-1, -1}};`	`{-1, -1}};`

`static void`	`static void`
`check (BOOL ok, const char *file, int line)`	`check (BOOL ok, const char *file, int line)`
`{`	`{`
`if (!ok)`	`if (!ok)`
`printf_filtered ("error return %s:%d was %lu\n", file, line,`	`printf_filtered ("error return %s:%d was %lu\n", file, line,`
`GetLastError ());`	`GetLastError ());`
`}`	`}`


`/* Find a thread record given a thread id.`	`/* Find a thread record given a thread id.`
`If get_context then also retrieve the context for this`	`If get_context then also retrieve the context for this`
`thread. */`	`thread. */`
`static thread_info *`	`static thread_info *`
`thread_rec (DWORD id, int get_context)`	`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)`
`{`	`{`
`if (get_context > 0 && id != current_event.dwThreadId)`	`if (get_context > 0 && id != current_event.dwThreadId)`
`th->suspend_count = SuspendThread (th->h) + 1;`	`th->suspend_count = SuspendThread (th->h) + 1;`
`else if (get_context < 0)`	`else if (get_context < 0)`
`th->suspend_count = -1;`	`th->suspend_count = -1;`

`th->context.ContextFlags = CONTEXT_DEBUGGER_DR;`	`th->context.ContextFlags = CONTEXT_DEBUGGER_DR;`
`GetThreadContext (th->h, &th->context);`	`GetThreadContext (th->h, &th->context);`
`if (id == current_event.dwThreadId)`	`if (id == current_event.dwThreadId)`
`{`	`{`
`/* Copy dr values from that thread. */`	`/* Copy dr values from that thread. */`
`dr[0] = th->context.Dr0;`	`dr[0] = th->context.Dr0;`
`dr[1] = th->context.Dr1;`	`dr[1] = th->context.Dr1;`
`dr[2] = th->context.Dr2;`	`dr[2] = th->context.Dr2;`
`dr[3] = th->context.Dr3;`	`dr[3] = th->context.Dr3;`
`dr[6] = th->context.Dr6;`	`dr[6] = th->context.Dr6;`
`dr[7] = th->context.Dr7;`	`dr[7] = th->context.Dr7;`
`}`	`}`
`}`	`}`
`return th;`	`return th;`
`}`	`}`

`return NULL;`	`return NULL;`
`}`	`}`

`/* 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;`

`if ((th = thread_rec (id, FALSE)))`	`if ((th = thread_rec (id, FALSE)))`
`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;`
`thread_head.next = th;`	`thread_head.next = th;`
`add_thread (pid_to_ptid (id));`	`add_thread (pid_to_ptid (id));`
`/* Set the debug registers for the new thread in they are used. */`	`/* Set the debug registers for the new thread in they are used. */`
`if (debug_registers_used)`	`if (debug_registers_used)`
`{`	`{`
`/* Only change the value of the debug registers. */`	`/* Only change the value of the debug registers. */`
`th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;`	`th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;`
`CHECK (GetThreadContext (th->h, &th->context));`	`CHECK (GetThreadContext (th->h, &th->context));`
`th->context.Dr0 = dr[0];`	`th->context.Dr0 = dr[0];`
`th->context.Dr1 = dr[1];`	`th->context.Dr1 = dr[1];`
`th->context.Dr2 = dr[2];`	`th->context.Dr2 = dr[2];`
`th->context.Dr3 = dr[3];`	`th->context.Dr3 = dr[3];`
`/* th->context.Dr6 = dr[6];`	`/* th->context.Dr6 = dr[6];`
`FIXME: should we set dr6 also ?? */`	`FIXME: should we set dr6 also ?? */`
`th->context.Dr7 = dr[7];`	`th->context.Dr7 = dr[7];`
`CHECK (SetThreadContext (th->h, &th->context));`	`CHECK (SetThreadContext (th->h, &th->context));`
`th->context.ContextFlags = 0;`	`th->context.ContextFlags = 0;`
`}`	`}`
`return th;`	`return th;`
`}`	`}`

`/* Clear out any old thread list and reintialize it to a`	`/* Clear out any old thread list and reintialize it to a`
`pristine state. */`	`pristine state. */`
`static void`	`static void`
`child_init_thread_list (void)`	`child_init_thread_list (void)`
`{`	`{`
`thread_info *th = &thread_head;`	`thread_info *th = &thread_head;`

`DEBUG_EVENTS (("gdb: child_init_thread_list\n"));`	`DEBUG_EVENTS (("gdb: child_init_thread_list\n"));`
`init_thread_list ();`	`init_thread_list ();`
`while (th->next != NULL)`	`while (th->next != NULL)`
`{`	`{`
`thread_info *here = th->next;`	`thread_info *here = th->next;`
`th->next = here->next;`	`th->next = here->next;`
`(void) CloseHandle (here->h);`	`(void) CloseHandle (here->h);`
`xfree (here);`	`xfree (here);`
`}`	`}`
`}`	`}`

`/* Delete a thread from the list of threads */`	`/* Delete a thread from the list of threads */`
`static void`	`static void`
`child_delete_thread (DWORD id)`	`child_delete_thread (DWORD id)`
`{`	`{`
`thread_info *th;`	`thread_info *th;`

`if (info_verbose)`	`if (info_verbose)`
`printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));`	`printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));`
`delete_thread (pid_to_ptid (id));`	`delete_thread (pid_to_ptid (id));`

`for (th = &thread_head;`	`for (th = &thread_head;`
`th->next != NULL && th->next->id != id;`	`th->next != NULL && th->next->id != id;`
`th = th->next)`	`th = th->next)`
`continue;`	`continue;`

`if (th->next != NULL)`	`if (th->next != NULL)`
`{`	`{`
`thread_info *here = th->next;`	`thread_info *here = th->next;`
`th->next = here->next;`	`th->next = here->next;`
`CloseHandle (here->h);`	`CloseHandle (here->h);`
`xfree (here);`	`xfree (here);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`do_child_fetch_inferior_registers (int r)`	`do_child_fetch_inferior_registers (int r)`
`{`	`{`
`char context_offset = ((char ) &current_thread->context) + mappings[r];`	`char context_offset = ((char ) &current_thread->context) + mappings[r];`
`long l;`	`long l;`
`if (r == FCS_REGNUM)`	`if (r == FCS_REGNUM)`
`{`	`{`
`l = ((long ) context_offset) & 0xffff;`	`l = ((long ) context_offset) & 0xffff;`
`supply_register (r, (char *) &l);`	`supply_register (r, (char *) &l);`
`}`	`}`
`else if (r == FOP_REGNUM)`	`else if (r == FOP_REGNUM)`
`{`	`{`
`l = (((long ) context_offset) >> 16) & ((1 << 11) - 1);`	`l = (((long ) context_offset) >> 16) & ((1 << 11) - 1);`
`supply_register (r, (char *) &l);`	`supply_register (r, (char *) &l);`
`}`	`}`
`else if (r >= 0)`	`else if (r >= 0)`
`supply_register (r, context_offset);`	`supply_register (r, context_offset);`
`else`	`else`
`{`	`{`
`for (r = 0; r < NUM_REGS; r++)`	`for (r = 0; r < NUM_REGS; r++)`
`do_child_fetch_inferior_registers (r);`	`do_child_fetch_inferior_registers (r);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`child_fetch_inferior_registers (int r)`	`child_fetch_inferior_registers (int r)`
`{`	`{`
`current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);`	`current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);`
`do_child_fetch_inferior_registers (r);`	`do_child_fetch_inferior_registers (r);`
`}`	`}`

`static void`	`static void`
`do_child_store_inferior_registers (int r)`	`do_child_store_inferior_registers (int r)`
`{`	`{`
`if (r >= 0)`	`if (r >= 0)`
`read_register_gen (r, ((char *) &current_thread->context) + mappings[r]);`	`read_register_gen (r, ((char *) &current_thread->context) + mappings[r]);`
`else`	`else`
`{`	`{`
`for (r = 0; r < NUM_REGS; r++)`	`for (r = 0; r < NUM_REGS; r++)`
`do_child_store_inferior_registers (r);`	`do_child_store_inferior_registers (r);`
`}`	`}`
`}`	`}`

`/* Store a new register value into the current thread context */`	`/* Store a new register value into the current thread context */`
`static void`	`static void`
`child_store_inferior_registers (int r)`	`child_store_inferior_registers (int r)`
`{`	`{`
`current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);`	`current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);`
`do_child_store_inferior_registers (r);`	`do_child_store_inferior_registers (r);`
`}`	`}`

`static int psapi_loaded = 0;`	`static int psapi_loaded = 0;`
`static HMODULE psapi_module_handle = NULL;`	`static HMODULE psapi_module_handle = NULL;`
`static BOOL WINAPI (psapi_EnumProcessModules) (HANDLE, HMODULE , DWORD, LPDWORD) = NULL;`	`static BOOL WINAPI (psapi_EnumProcessModules) (HANDLE, HMODULE , DWORD, LPDWORD) = NULL;`
`static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;`	`static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;`
`static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;`	`static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;`

`int`	`int`
`psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)`	`psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)`
`{`	`{`
`DWORD len;`	`DWORD len;`
`MODULEINFO mi;`	`MODULEINFO mi;`
`int i;`	`int i;`
`HMODULE dh_buf[1];`	`HMODULE dh_buf[1];`
`HMODULE *DllHandle = dh_buf;`	`HMODULE *DllHandle = dh_buf;`
`DWORD cbNeeded;`	`DWORD cbNeeded;`
`BOOL ok;`	`BOOL ok;`

`if (!psapi_loaded \|\|`	`if (!psapi_loaded \|\|`
`psapi_EnumProcessModules == NULL \|\|`	`psapi_EnumProcessModules == NULL \|\|`
`psapi_GetModuleInformation == NULL \|\|`	`psapi_GetModuleInformation == NULL \|\|`
`psapi_GetModuleFileNameExA == NULL)`	`psapi_GetModuleFileNameExA == NULL)`
`{`	`{`
`if (psapi_loaded)`	`if (psapi_loaded)`
`goto failed;`	`goto failed;`
`psapi_loaded = 1;`	`psapi_loaded = 1;`
`psapi_module_handle = LoadLibrary ("psapi.dll");`	`psapi_module_handle = LoadLibrary ("psapi.dll");`
`if (!psapi_module_handle)`	`if (!psapi_module_handle)`
`{`	`{`
`/* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */`	`/* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */`
`goto failed;`	`goto failed;`
`}`	`}`
`psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");`	`psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");`
`psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");`	`psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");`
`psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,`	`psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,`
`"GetModuleFileNameExA");`	`"GetModuleFileNameExA");`
`if (psapi_EnumProcessModules == NULL \|\|`	`if (psapi_EnumProcessModules == NULL \|\|`
`psapi_GetModuleInformation == NULL \|\|`	`psapi_GetModuleInformation == NULL \|\|`
`psapi_GetModuleFileNameExA == NULL)`	`psapi_GetModuleFileNameExA == NULL)`
`goto failed;`	`goto failed;`
`}`	`}`

`cbNeeded = 0;`	`cbNeeded = 0;`
`ok = (*psapi_EnumProcessModules) (current_process_handle,`	`ok = (*psapi_EnumProcessModules) (current_process_handle,`
`DllHandle,`	`DllHandle,`
`sizeof (HMODULE),`	`sizeof (HMODULE),`
`&cbNeeded);`	`&cbNeeded);`

`if (!ok \|\| !cbNeeded)`	`if (!ok \|\| !cbNeeded)`
`goto failed;`	`goto failed;`

`DllHandle = (HMODULE *) alloca (cbNeeded);`	`DllHandle = (HMODULE *) alloca (cbNeeded);`
`if (!DllHandle)`	`if (!DllHandle)`
`goto failed;`	`goto failed;`

`ok = (*psapi_EnumProcessModules) (current_process_handle,`	`ok = (*psapi_EnumProcessModules) (current_process_handle,`
`DllHandle,`	`DllHandle,`
`cbNeeded,`	`cbNeeded,`
`&cbNeeded);`	`&cbNeeded);`
`if (!ok)`	`if (!ok)`
`goto failed;`	`goto failed;`

`for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)`	`for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)`
`{`	`{`
`if (!(*psapi_GetModuleInformation) (current_process_handle,`	`if (!(*psapi_GetModuleInformation) (current_process_handle,`
`DllHandle[i],`	`DllHandle[i],`
`&mi,`	`&mi,`
`sizeof (mi)))`	`sizeof (mi)))`
`error ("Can't get module info");`	`error ("Can't get module info");`

`len = (*psapi_GetModuleFileNameExA) (current_process_handle,`	`len = (*psapi_GetModuleFileNameExA) (current_process_handle,`
`DllHandle[i],`	`DllHandle[i],`
`dll_name_ret,`	`dll_name_ret,`
`MAX_PATH);`	`MAX_PATH);`
`if (len == 0)`	`if (len == 0)`
`error ("Error getting dll name: %u\n", (unsigned) GetLastError ());`	`error ("Error getting dll name: %u\n", (unsigned) GetLastError ());`

`if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)`	`if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)`
`return 1;`	`return 1;`
`}`	`}`

`failed:`	`failed:`
`dll_name_ret[0] = '\0';`	`dll_name_ret[0] = '\0';`
`return 0;`	`return 0;`
`}`	`}`

`/* Encapsulate the information required in a call to`	`/* Encapsulate the information required in a call to`
`symbol_file_add_args */`	`symbol_file_add_args */`
`struct safe_symbol_file_add_args`	`struct safe_symbol_file_add_args`
`{`	`{`
`char *name;`	`char *name;`
`int from_tty;`	`int from_tty;`
`struct section_addr_info *addrs;`	`struct section_addr_info *addrs;`
`int mainline;`	`int mainline;`
`int flags;`	`int flags;`
`struct ui_file err, out;`	`struct ui_file err, out;`
`struct objfile *ret;`	`struct objfile *ret;`
`};`	`};`

`/* Maintain a linked list of "so" information. */`	`/* Maintain a linked list of "so" information. */`
`struct so_stuff`	`struct so_stuff`
`{`	`{`
`struct so_stuff *next;`	`struct so_stuff *next;`
`DWORD load_addr;`	`DWORD load_addr;`
`DWORD end_addr;`	`DWORD end_addr;`
`int loaded;`	`int loaded;`
`struct objfile *objfile;`	`struct objfile *objfile;`
`char name[1];`	`char name[1];`
`} solib_start, *solib_end;`	`} solib_start, *solib_end;`

`/* Call symbol_file_add with stderr redirected. We don't care if there`	`/* Call symbol_file_add with stderr redirected. We don't care if there`
`are errors. */`	`are errors. */`
`static int`	`static int`
`safe_symbol_file_add_stub (void *argv)`	`safe_symbol_file_add_stub (void *argv)`
`{`	`{`
`#define p ((struct safe_symbol_file_add_args *)argv)`	`#define p ((struct safe_symbol_file_add_args *)argv)`
`struct so_stuff *so = &solib_start;`	`struct so_stuff *so = &solib_start;`

`while ((so = so->next))`	`while ((so = so->next))`
`if (so->loaded && strcasecmp (so->name, p->name) == 0)`	`if (so->loaded && strcasecmp (so->name, p->name) == 0)`
`return 0;`	`return 0;`
`p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);`	`p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);`
`return !!p->ret;`	`return !!p->ret;`
`#undef p`	`#undef p`
`}`	`}`

`/* Restore gdb's stderr after calling symbol_file_add */`	`/* Restore gdb's stderr after calling symbol_file_add */`
`static void`	`static void`
`safe_symbol_file_add_cleanup (void *p)`	`safe_symbol_file_add_cleanup (void *p)`
`{`	`{`
`#define sp ((struct safe_symbol_file_add_args *)p)`	`#define sp ((struct safe_symbol_file_add_args *)p)`
`gdb_flush (gdb_stderr);`	`gdb_flush (gdb_stderr);`
`gdb_flush (gdb_stdout);`	`gdb_flush (gdb_stdout);`
`ui_file_delete (gdb_stderr);`	`ui_file_delete (gdb_stderr);`
`ui_file_delete (gdb_stdout);`	`ui_file_delete (gdb_stdout);`
`gdb_stderr = sp->err;`	`gdb_stderr = sp->err;`
`gdb_stdout = sp->out;`	`gdb_stdout = sp->out;`
`#undef sp`	`#undef sp`
`}`	`}`

`/* symbol_file_add wrapper that prevents errors from being displayed. */`	`/* symbol_file_add wrapper that prevents errors from being displayed. */`
`static struct objfile *`	`static struct objfile *`
`safe_symbol_file_add (char *name, int from_tty,`	`safe_symbol_file_add (char *name, int from_tty,`
`struct section_addr_info *addrs,`	`struct section_addr_info *addrs,`
`int mainline, int flags)`	`int mainline, int flags)`
`{`	`{`
`struct safe_symbol_file_add_args p;`	`struct safe_symbol_file_add_args p;`
`struct cleanup *cleanup;`	`struct cleanup *cleanup;`

`cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);`	`cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);`

`p.err = gdb_stderr;`	`p.err = gdb_stderr;`
`p.out = gdb_stdout;`	`p.out = gdb_stdout;`
`gdb_flush (gdb_stderr);`	`gdb_flush (gdb_stderr);`
`gdb_flush (gdb_stdout);`	`gdb_flush (gdb_stdout);`
`gdb_stderr = ui_file_new ();`	`gdb_stderr = ui_file_new ();`
`gdb_stdout = ui_file_new ();`	`gdb_stdout = ui_file_new ();`
`p.name = name;`	`p.name = name;`
`p.from_tty = from_tty;`	`p.from_tty = from_tty;`
`p.addrs = addrs;`	`p.addrs = addrs;`
`p.mainline = mainline;`	`p.mainline = mainline;`
`p.flags = flags;`	`p.flags = flags;`
`catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);`	`catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);`

`do_cleanups (cleanup);`	`do_cleanups (cleanup);`
`return p.ret;`	`return p.ret;`
`}`	`}`

`/* Remember the maximum DLL length for printing in info dll command. */`	`/* Remember the maximum DLL length for printing in info dll command. */`
`int max_dll_name_len;`	`int max_dll_name_len;`

`static void`	`static void`
`register_loaded_dll (const char *name, DWORD load_addr)`	`register_loaded_dll (const char *name, DWORD load_addr)`
`{`	`{`
`struct so_stuff *so;`	`struct so_stuff *so;`
`char ppath[MAX_PATH + 1];`	`char ppath[MAX_PATH + 1];`
`char buf[MAX_PATH + 1];`	`char buf[MAX_PATH + 1];`
`char cwd[MAX_PATH + 1];`	`char cwd[MAX_PATH + 1];`
`char *p;`	`char *p;`
`WIN32_FIND_DATA w32_fd;`	`WIN32_FIND_DATA w32_fd;`
`HANDLE h = FindFirstFile(name, &w32_fd);`	`HANDLE h = FindFirstFile(name, &w32_fd);`
`MEMORY_BASIC_INFORMATION m;`	`MEMORY_BASIC_INFORMATION m;`
`size_t len;`	`size_t len;`

`if (h == INVALID_HANDLE_VALUE)`	`if (h == INVALID_HANDLE_VALUE)`
`strcpy (buf, name);`	`strcpy (buf, name);`
`else`	`else`
`{`	`{`
`FindClose (h);`	`FindClose (h);`
`strcpy (buf, name);`	`strcpy (buf, name);`
`if (GetCurrentDirectory (MAX_PATH + 1, cwd))`	`if (GetCurrentDirectory (MAX_PATH + 1, cwd))`
`{`	`{`
`p = strrchr (buf, '\\');`	`p = strrchr (buf, '\\');`
`if (p)`	`if (p)`
`p[1] = '\0';`	`p[1] = '\0';`
`SetCurrentDirectory (buf);`	`SetCurrentDirectory (buf);`
`GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);`	`GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);`
`SetCurrentDirectory (cwd);`	`SetCurrentDirectory (cwd);`
`}`	`}`
`}`	`}`

`cygwin_conv_to_posix_path (buf, ppath);`	`cygwin_conv_to_posix_path (buf, ppath);`
`so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);`	`so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);`
`so->loaded = 0;`	`so->loaded = 0;`
`so->load_addr = load_addr;`	`so->load_addr = load_addr;`
`if (!VirtualQueryEx (current_process_handle, (void *) load_addr, &m,`	`if (!VirtualQueryEx (current_process_handle, (void *) load_addr, &m,`
`sizeof (m)))`	`sizeof (m)))`
`so->end_addr = (DWORD) m.AllocationBase + m.RegionSize;`	`so->end_addr = (DWORD) m.AllocationBase + m.RegionSize;`
`else`	`else`
`so->end_addr = load_addr + 0x2000; /* completely arbitrary */`	`so->end_addr = load_addr + 0x2000; /* completely arbitrary */`

`so->next = NULL;`	`so->next = NULL;`
`so->objfile = NULL;`	`so->objfile = NULL;`
`strcpy (so->name, ppath);`	`strcpy (so->name, ppath);`

`solib_end->next = so;`	`solib_end->next = so;`
`solib_end = so;`	`solib_end = so;`
`len = strlen (ppath);`	`len = strlen (ppath);`
`if (len > max_dll_name_len)`	`if (len > max_dll_name_len)`
`max_dll_name_len = len;`	`max_dll_name_len = len;`
`}`	`}`

`char *`	`char *`
`get_image_name (HANDLE h, void *address, int unicode)`	`get_image_name (HANDLE h, void *address, int unicode)`
`{`	`{`
`static char buf[(2 * MAX_PATH) + 1];`	`static char buf[(2 * MAX_PATH) + 1];`
`DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);`	`DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);`
`char *address_ptr;`	`char *address_ptr;`
`int len = 0;`	`int len = 0;`
`char b[2];`	`char b[2];`
`DWORD done;`	`DWORD done;`

`/* Attempt to read the name of the dll that was detected.`	`/* Attempt to read the name of the dll that was detected.`
`This is documented to work only when actively debugging`	`This is documented to work only when actively debugging`
`a program. It will not work for attached processes. */`	`a program. It will not work for attached processes. */`
`if (address == NULL)`	`if (address == NULL)`
`return NULL;`	`return NULL;`

`ReadProcessMemory (h, address, &address_ptr, sizeof (address_ptr), &done);`	`ReadProcessMemory (h, address, &address_ptr, sizeof (address_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 (address_ptr) \|\| !address_ptr)`	`if (done != sizeof (address_ptr) \|\| !address_ptr)`
`return NULL;`	`return NULL;`

`/* Find the length of the string */`	`/* Find the length of the string */`
`do`	`do`
`{`	`{`
`ReadProcessMemory (h, address_ptr + len * size, &b, size, &done);`	`ReadProcessMemory (h, address_ptr + len * size, &b, size, &done);`
`len++;`	`len++;`
`}`	`}`
`while ((b[0] != 0 \|\| b[size - 1] != 0) && done == size);`	`while ((b[0] != 0 \|\| b[size - 1] != 0) && done == size);`

`if (!unicode)`	`if (!unicode)`
`ReadProcessMemory (h, address_ptr, buf, len, &done);`	`ReadProcessMemory (h, address_ptr, buf, len, &done);`
`else`	`else`
`{`	`{`
`WCHAR unicode_address = (WCHAR ) alloca (len * sizeof (WCHAR));`	`WCHAR unicode_address = (WCHAR ) alloca (len * sizeof (WCHAR));`
`ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),`	`ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),`
`&done);`	`&done);`

`WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);`	`WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);`
`}`	`}`

`return buf;`	`return buf;`
`}`	`}`

`/* Wait for child to do something. Return pid of child, or -1 in case`	`/* Wait for child to do something. Return pid of child, or -1 in case`
`of error; store status through argument pointer OURSTATUS. */`	`of error; store status through argument pointer OURSTATUS. */`
`static int`	`static int`
`handle_load_dll (void *dummy)`	`handle_load_dll (void *dummy)`
`{`	`{`
`LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;`	`LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;`
`char dll_buf[MAX_PATH + 1];`	`char dll_buf[MAX_PATH + 1];`
`char *dll_name = NULL;`	`char *dll_name = NULL;`
`char *p;`	`char *p;`

`dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';`	`dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';`

`if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))`	`if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))`
`dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';`	`dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';`

`dll_name = dll_buf;`	`dll_name = dll_buf;`

`if (*dll_name == '\0')`	`if (*dll_name == '\0')`
`dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode);`	`dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode);`
`if (!dll_name)`	`if (!dll_name)`
`return 1;`	`return 1;`

`register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);`	`register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);`

`return 1;`	`return 1;`
`}`	`}`

`static int`	`static int`
`handle_unload_dll (void *dummy)`	`handle_unload_dll (void *dummy)`
`{`	`{`
`DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;`	`DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;`
`struct so_stuff *so;`	`struct so_stuff *so;`

`for (so = &solib_start; so->next != NULL; so = so->next)`	`for (so = &solib_start; so->next != NULL; so = so->next)`
`if (so->next->load_addr == lpBaseOfDll)`	`if (so->next->load_addr == lpBaseOfDll)`
`{`	`{`
`struct so_stuff *sodel = so->next;`	`struct so_stuff *sodel = so->next;`
`so->next = sodel->next;`	`so->next = sodel->next;`
`if (!so->next)`	`if (!so->next)`
`solib_end = so;`	`solib_end = so;`
`if (sodel->objfile)`	`if (sodel->objfile)`
`free_objfile (sodel->objfile);`	`free_objfile (sodel->objfile);`
`xfree(sodel);`	`xfree(sodel);`
`return 1;`	`return 1;`
`}`	`}`
`error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);`	`error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);`

`return 0;`	`return 0;`
`}`	`}`

`char *`	`char *`
`solib_address (CORE_ADDR address)`	`solib_address (CORE_ADDR address)`
`{`	`{`
`struct so_stuff *so;`	`struct so_stuff *so;`
`for (so = &solib_start; so->next != NULL; so = so->next)`	`for (so = &solib_start; so->next != NULL; so = so->next)`
`if (address >= so->load_addr && address <= so->end_addr)`	`if (address >= so->load_addr && address <= so->end_addr)`
`return so->name;`	`return so->name;`
`return NULL;`	`return NULL;`
`}`	`}`

`/* Return name of last loaded DLL. */`	`/* Return name of last loaded DLL. */`
`char *`	`char *`
`child_solib_loaded_library_pathname (int pid)`	`child_solib_loaded_library_pathname (int pid)`
`{`	`{`
`return !solib_end \|\| !solib_end->name[0] ? NULL : solib_end->name;`	`return !solib_end \|\| !solib_end->name[0] ? NULL : solib_end->name;`
`}`	`}`

`/* Clear list of loaded DLLs. */`	`/* Clear list of loaded DLLs. */`
`void`	`void`
`child_clear_solibs (void)`	`child_clear_solibs (void)`
`{`	`{`
`struct so_stuff so, so1 = solib_start.next;`	`struct so_stuff so, so1 = solib_start.next;`

`while ((so = so1) != NULL)`	`while ((so = so1) != NULL)`
`{`	`{`
`so1 = so->next;`	`so1 = so->next;`
`xfree (so);`	`xfree (so);`
`}`	`}`

`solib_start.next = NULL;`	`solib_start.next = NULL;`
`solib_start.objfile = NULL;`	`solib_start.objfile = NULL;`
`solib_end = &solib_start;`	`solib_end = &solib_start;`
`max_dll_name_len = sizeof ("DLL Name") - 1;`	`max_dll_name_len = sizeof ("DLL Name") - 1;`
`}`	`}`

`/* Add DLL symbol information. */`	`/* Add DLL symbol information. */`
`static struct objfile *`	`static struct objfile *`
`solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)`	`solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)`
`{`	`{`
`struct section_addr_info section_addrs;`	`struct section_addr_info section_addrs;`

`/* The symbols in a dll are offset by 0x1000, which is the`	`/* The symbols in a dll are offset by 0x1000, which is the`
`the offset from 0 of the first byte in an image - because`	`the offset from 0 of the first byte in an image - because`
`of the file header and the section alignment. */`	`of the file header and the section alignment. */`

`if (!name \|\| !name[0])`	`if (!name \|\| !name[0])`
`return NULL;`	`return NULL;`

`memset (&section_addrs, 0, sizeof (section_addrs));`	`memset (&section_addrs, 0, sizeof (section_addrs));`
`section_addrs.other[0].name = ".text";`	`section_addrs.other[0].name = ".text";`
`section_addrs.other[0].addr = load_addr;`	`section_addrs.other[0].addr = load_addr;`
`return safe_symbol_file_add (name, from_tty, &section_addrs, 0, OBJF_SHARED);`	`return safe_symbol_file_add (name, from_tty, &section_addrs, 0, OBJF_SHARED);`
`}`	`}`

`/* Load DLL symbol info. */`	`/* Load DLL symbol info. */`
`void`	`void`
`dll_symbol_command (char *args, int from_tty)`	`dll_symbol_command (char *args, int from_tty)`
`{`	`{`
`int n;`	`int n;`
`dont_repeat ();`	`dont_repeat ();`

`if (args == NULL)`	`if (args == NULL)`
`error ("dll-symbols requires a file name");`	`error ("dll-symbols requires a file name");`

`n = strlen (args);`	`n = strlen (args);`
`if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)`	`if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)`
`{`	`{`
`char newargs = (char ) alloca (n + 4 + 1);`	`char newargs = (char ) alloca (n + 4 + 1);`
`strcpy (newargs, args);`	`strcpy (newargs, args);`
`strcat (newargs, ".dll");`	`strcat (newargs, ".dll");`
`args = newargs;`	`args = newargs;`
`}`	`}`

`safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED \| OBJF_USERLOADED);`	`safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED \| OBJF_USERLOADED);`
`}`	`}`

`/* List currently loaded DLLs. */`	`/* List currently loaded DLLs. */`
`void`	`void`
`info_dll_command (char *ignore, int from_tty)`	`info_dll_command (char *ignore, int from_tty)`
`{`	`{`
`struct so_stuff *so = &solib_start;`	`struct so_stuff *so = &solib_start;`

`if (!so->next)`	`if (!so->next)`
`return;`	`return;`

`printf_filtered ("%*s Load Address\n", -max_dll_name_len, "DLL Name");`	`printf_filtered ("%*s Load Address\n", -max_dll_name_len, "DLL Name");`
`while ((so = so->next) != NULL)`	`while ((so = so->next) != NULL)`
`printf_filtered ("%*s %08lx\n", -max_dll_name_len, so->name, so->load_addr);`	`printf_filtered ("%*s %08lx\n", -max_dll_name_len, so->name, so->load_addr);`

`return;`	`return;`
`}`	`}`

`/* Handle DEBUG_STRING output from child process.`	`/* Handle DEBUG_STRING output from child process.`
`Cygwin prepends its messages with a "cygwin:". Interpret this as`	`Cygwin prepends its messages with a "cygwin:". Interpret this as`
`a Cygwin signal. Otherwise just print the string as a warning. */`	`a Cygwin signal. Otherwise just print the string as a warning. */`
`static int`	`static int`
`handle_output_debug_string (struct target_waitstatus *ourstatus)`	`handle_output_debug_string (struct target_waitstatus *ourstatus)`
`{`	`{`
`char *s;`	`char *s;`
`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) != 0)`	`if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)`
`{`	`{`
`if (strncmp (s, "cYg", 3) != 0)`	`if (strncmp (s, "cYg", 3) != 0)`
`warning ("%s", s);`	`warning ("%s", s);`
`}`	`}`
`else`	`else`
`{`	`{`
`char *p;`	`char *p;`
`int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);`	`int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);`
`gotasig = target_signal_from_host (sig);`	`gotasig = target_signal_from_host (sig);`
`ourstatus->value.sig = gotasig;`	`ourstatus->value.sig = gotasig;`
`if (gotasig)`	`if (gotasig)`
`ourstatus->kind = TARGET_WAITKIND_STOPPED;`	`ourstatus->kind = TARGET_WAITKIND_STOPPED;`
`}`	`}`

`xfree (s);`	`xfree (s);`
`return gotasig;`	`return gotasig;`
`}`	`}`

`static int`	`static int`
`display_selector (HANDLE thread, DWORD sel)`	`display_selector (HANDLE thread, DWORD sel)`
`{`	`{`
`LDT_ENTRY info;`	`LDT_ENTRY info;`
`if (GetThreadSelectorEntry (thread, sel, &info))`	`if (GetThreadSelectorEntry (thread, sel, &info))`
`{`	`{`
`int base, limit;`	`int base, limit;`
`printf_filtered ("0x%03lx: ", sel);`	`printf_filtered ("0x%03lx: ", sel);`
`if (!info.HighWord.Bits.Pres)`	`if (!info.HighWord.Bits.Pres)`
`{`	`{`
`puts_filtered ("Segment not present\n");`	`puts_filtered ("Segment not present\n");`
`return 0;`	`return 0;`
`}`	`}`
`base = (info.HighWord.Bits.BaseHi << 24) +`	`base = (info.HighWord.Bits.BaseHi << 24) +`
`(info.HighWord.Bits.BaseMid << 16)`	`(info.HighWord.Bits.BaseMid << 16)`
`+ info.BaseLow;`	`+ info.BaseLow;`
`limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;`	`limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;`
`if (info.HighWord.Bits.Granularity)`	`if (info.HighWord.Bits.Granularity)`
`limit = (limit << 12) \| 0xfff;`	`limit = (limit << 12) \| 0xfff;`
`printf_filtered ("base=0x%08x limit=0x%08x", base, limit);`	`printf_filtered ("base=0x%08x limit=0x%08x", base, limit);`
`if (info.HighWord.Bits.Default_Big)`	`if (info.HighWord.Bits.Default_Big)`
`puts_filtered(" 32-bit ");`	`puts_filtered(" 32-bit ");`
`else`	`else`
`puts_filtered(" 16-bit ");`	`puts_filtered(" 16-bit ");`
`switch ((info.HighWord.Bits.Type & 0xf) >> 1)`	`switch ((info.HighWord.Bits.Type & 0xf) >> 1)`
`{`	`{`
`case 0:`	`case 0:`
`puts_filtered ("Data (Read-Only, Exp-up");`	`puts_filtered ("Data (Read-Only, Exp-up");`
`break;`	`break;`
`case 1:`	`case 1:`
`puts_filtered ("Data (Read/Write, Exp-up");`	`puts_filtered ("Data (Read/Write, Exp-up");`
`break;`	`break;`
`case 2:`	`case 2:`
`puts_filtered ("Unused segment (");`	`puts_filtered ("Unused segment (");`
`break;`	`break;`
`case 3:`	`case 3:`
`puts_filtered ("Data (Read/Write, Exp-down");`	`puts_filtered ("Data (Read/Write, Exp-down");`
`break;`	`break;`
`case 4:`	`case 4:`
`puts_filtered ("Code (Exec-Only, N.Conf");`	`puts_filtered ("Code (Exec-Only, N.Conf");`
`break;`	`break;`
`case 5:`	`case 5:`
`puts_filtered ("Code (Exec/Read, N.Conf");`	`puts_filtered ("Code (Exec/Read, N.Conf");`
`break;`	`break;`
`case 6:`	`case 6:`
`puts_filtered ("Code (Exec-Only, Conf");`	`puts_filtered ("Code (Exec-Only, Conf");`
`break;`	`break;`
`case 7:`	`case 7:`
`puts_filtered ("Code (Exec/Read, Conf");`	`puts_filtered ("Code (Exec/Read, Conf");`
`break;`	`break;`
`default:`	`default:`
`printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);`	`printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);`
`}`	`}`
`if ((info.HighWord.Bits.Type & 0x1) == 0)`	`if ((info.HighWord.Bits.Type & 0x1) == 0)`
`puts_filtered(", N.Acc");`	`puts_filtered(", N.Acc");`
`puts_filtered (")\n");`	`puts_filtered (")\n");`
`if ((info.HighWord.Bits.Type & 0x10) == 0)`	`if ((info.HighWord.Bits.Type & 0x10) == 0)`
`puts_filtered("System selector ");`	`puts_filtered("System selector ");`
`printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);`	`printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);`
`if (info.HighWord.Bits.Granularity)`	`if (info.HighWord.Bits.Granularity)`
`puts_filtered ("Page granular.\n");`	`puts_filtered ("Page granular.\n");`
`else`	`else`
`puts_filtered ("Byte granular.\n");`	`puts_filtered ("Byte granular.\n");`
`return 1;`	`return 1;`
`}`	`}`
`else`	`else`
`{`	`{`
`printf_filtered ("Invalid selector 0x%lx.\n",sel);`	`printf_filtered ("Invalid selector 0x%lx.\n",sel);`
`return 0;`	`return 0;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`display_selectors (char * args, int from_tty)`	`display_selectors (char * args, int from_tty)`
`{`	`{`
`if (!current_thread)`	`if (!current_thread)`
`{`	`{`
`puts_filtered ("Impossible to display selectors now.\n");`	`puts_filtered ("Impossible to display selectors now.\n");`
`return;`	`return;`
`}`	`}`
`if (!args)`	`if (!args)`
`{`	`{`

`puts_filtered ("Selector $cs\n");`	`puts_filtered ("Selector $cs\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegCs);`	`current_thread->context.SegCs);`
`puts_filtered ("Selector $ds\n");`	`puts_filtered ("Selector $ds\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegDs);`	`current_thread->context.SegDs);`
`puts_filtered ("Selector $es\n");`	`puts_filtered ("Selector $es\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegEs);`	`current_thread->context.SegEs);`
`puts_filtered ("Selector $ss\n");`	`puts_filtered ("Selector $ss\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegSs);`	`current_thread->context.SegSs);`
`puts_filtered ("Selector $fs\n");`	`puts_filtered ("Selector $fs\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegFs);`	`current_thread->context.SegFs);`
`puts_filtered ("Selector $gs\n");`	`puts_filtered ("Selector $gs\n");`
`display_selector (current_thread->h,`	`display_selector (current_thread->h,`
`current_thread->context.SegGs);`	`current_thread->context.SegGs);`
`}`	`}`
`else`	`else`
`{`	`{`
`int sel;`	`int sel;`
`sel = parse_and_eval_long (args);`	`sel = parse_and_eval_long (args);`
`printf_filtered ("Selector \"%s\"\n",args);`	`printf_filtered ("Selector \"%s\"\n",args);`
`display_selector (current_thread->h, sel);`	`display_selector (current_thread->h, sel);`
`}`	`}`
`}`	`}`

`static struct cmd_list_element *info_w32_cmdlist = NULL;`	`static struct cmd_list_element *info_w32_cmdlist = NULL;`

`static void`	`static void`
`info_w32_command (char *args, int from_tty)`	`info_w32_command (char *args, int from_tty)`
`{`	`{`
`help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);`	`help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);`
`}`	`}`


`#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \`	`#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \`
`printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \`	`printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \`
`(DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)`	`(DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)`

`static int`	`static int`
`handle_exception (struct target_waitstatus *ourstatus)`	`handle_exception (struct target_waitstatus *ourstatus)`
`{`	`{`
`thread_info *th;`	`thread_info *th;`
`DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;`	`DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;`

`ourstatus->kind = TARGET_WAITKIND_STOPPED;`	`ourstatus->kind = TARGET_WAITKIND_STOPPED;`

`/* Record the context of the current thread */`	`/* Record the context of the current thread */`
`th = thread_rec (current_event.dwThreadId, -1);`	`th = thread_rec (current_event.dwThreadId, -1);`

`switch (code)`	`switch (code)`
`{`	`{`
`case EXCEPTION_ACCESS_VIOLATION:`	`case EXCEPTION_ACCESS_VIOLATION:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");`
`ourstatus->value.sig = TARGET_SIGNAL_SEGV;`	`ourstatus->value.sig = TARGET_SIGNAL_SEGV;`
`break;`	`break;`
`case STATUS_STACK_OVERFLOW:`	`case STATUS_STACK_OVERFLOW:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");`
`ourstatus->value.sig = TARGET_SIGNAL_SEGV;`	`ourstatus->value.sig = TARGET_SIGNAL_SEGV;`
`break;`	`break;`
`case STATUS_FLOAT_DENORMAL_OPERAND:`	`case STATUS_FLOAT_DENORMAL_OPERAND:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:`	`case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_INEXACT_RESULT:`	`case STATUS_FLOAT_INEXACT_RESULT:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_INVALID_OPERATION:`	`case STATUS_FLOAT_INVALID_OPERATION:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_OVERFLOW:`	`case STATUS_FLOAT_OVERFLOW:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_STACK_CHECK:`	`case STATUS_FLOAT_STACK_CHECK:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_UNDERFLOW:`	`case STATUS_FLOAT_UNDERFLOW:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_FLOAT_DIVIDE_BY_ZERO:`	`case STATUS_FLOAT_DIVIDE_BY_ZERO:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_INTEGER_DIVIDE_BY_ZERO:`	`case STATUS_INTEGER_DIVIDE_BY_ZERO:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case STATUS_INTEGER_OVERFLOW:`	`case STATUS_INTEGER_OVERFLOW:`
`DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");`	`DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");`
`ourstatus->value.sig = TARGET_SIGNAL_FPE;`	`ourstatus->value.sig = TARGET_SIGNAL_FPE;`
`break;`	`break;`
`case EXCEPTION_BREAKPOINT:`	`case EXCEPTION_BREAKPOINT:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");`
`ourstatus->value.sig = TARGET_SIGNAL_TRAP;`	`ourstatus->value.sig = TARGET_SIGNAL_TRAP;`
`break;`	`break;`
`case DBG_CONTROL_C:`	`case DBG_CONTROL_C:`
`DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");`	`DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");`
`ourstatus->value.sig = TARGET_SIGNAL_INT;`	`ourstatus->value.sig = TARGET_SIGNAL_INT;`
`break;`	`break;`
`case DBG_CONTROL_BREAK:`	`case DBG_CONTROL_BREAK:`
`DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");`	`DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");`
`ourstatus->value.sig = TARGET_SIGNAL_INT;`	`ourstatus->value.sig = TARGET_SIGNAL_INT;`
`break;`	`break;`
`case EXCEPTION_SINGLE_STEP:`	`case EXCEPTION_SINGLE_STEP:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");`
`ourstatus->value.sig = TARGET_SIGNAL_TRAP;`	`ourstatus->value.sig = TARGET_SIGNAL_TRAP;`
`break;`	`break;`
`case EXCEPTION_ILLEGAL_INSTRUCTION:`	`case EXCEPTION_ILLEGAL_INSTRUCTION:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");`
`ourstatus->value.sig = TARGET_SIGNAL_ILL;`	`ourstatus->value.sig = TARGET_SIGNAL_ILL;`
`break;`	`break;`
`case EXCEPTION_PRIV_INSTRUCTION:`	`case EXCEPTION_PRIV_INSTRUCTION:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");`
`ourstatus->value.sig = TARGET_SIGNAL_ILL;`	`ourstatus->value.sig = TARGET_SIGNAL_ILL;`
`break;`	`break;`
`case EXCEPTION_NONCONTINUABLE_EXCEPTION:`	`case EXCEPTION_NONCONTINUABLE_EXCEPTION:`
`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");`	`DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");`
`ourstatus->value.sig = TARGET_SIGNAL_ILL;`	`ourstatus->value.sig = TARGET_SIGNAL_ILL;`
`break;`	`break;`
`default:`	`default:`
`if (current_event.u.Exception.dwFirstChance)`	`if (current_event.u.Exception.dwFirstChance)`
`return 0;`	`return 0;`
`printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",`	`printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",`
`current_event.u.Exception.ExceptionRecord.ExceptionCode,`	`current_event.u.Exception.ExceptionRecord.ExceptionCode,`
`(DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);`	`(DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);`
`ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;`	`ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;`
`break;`	`break;`
`}`	`}`
`exception_count++;`	`exception_count++;`
`last_sig = ourstatus->value.sig;`	`last_sig = ourstatus->value.sig;`
`return 1;`	`return 1;`
`}`	`}`

`/* Resume all artificially suspended threads if we are continuing`	`/* Resume all artificially suspended threads if we are continuing`
`execution */`	`execution */`
`static BOOL`	`static BOOL`
`child_continue (DWORD continue_status, int id)`	`child_continue (DWORD continue_status, int id)`
`{`	`{`
`int i;`	`int i;`
`thread_info *th;`	`thread_info *th;`
`BOOL res;`	`BOOL res;`

`DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",`	`DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",`
`current_event.dwProcessId, current_event.dwThreadId,`	`current_event.dwProcessId, current_event.dwThreadId,`
`continue_status == DBG_CONTINUE ?`	`continue_status == DBG_CONTINUE ?`
`"DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));`	`"DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));`
`res = ContinueDebugEvent (current_event.dwProcessId,`	`res = ContinueDebugEvent (current_event.dwProcessId,`
`current_event.dwThreadId,`	`current_event.dwThreadId,`
`continue_status);`	`continue_status);`
`continue_status = 0;`	`continue_status = 0;`
`if (res)`	`if (res)`
`for (th = &thread_head; (th = th->next) != NULL;)`	`for (th = &thread_head; (th = th->next) != NULL;)`
`if (((id == -1) \|\| (id == (int) th->id)) && th->suspend_count)`	`if (((id == -1) \|\| (id == (int) th->id)) && th->suspend_count)`
`{`	`{`

`for (i = 0; i < th->suspend_count; i++)`	`for (i = 0; i < th->suspend_count; i++)`
`(void) ResumeThread (th->h);`	`(void) ResumeThread (th->h);`
`th->suspend_count = 0;`	`th->suspend_count = 0;`
`if (debug_registers_changed)`	`if (debug_registers_changed)`
`{`	`{`
`/* Only change the value of the debug reisters */`	`/* Only change the value of the debug reisters */`
`th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;`	`th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;`
`th->context.Dr0 = dr[0];`	`th->context.Dr0 = dr[0];`
`th->context.Dr1 = dr[1];`	`th->context.Dr1 = dr[1];`
`th->context.Dr2 = dr[2];`	`th->context.Dr2 = dr[2];`
`th->context.Dr3 = dr[3];`	`th->context.Dr3 = dr[3];`
`/* th->context.Dr6 = dr[6];`	`/* th->context.Dr6 = dr[6];`
`FIXME: should we set dr6 also ?? */`	`FIXME: should we set dr6 also ?? */`
`th->context.Dr7 = dr[7];`	`th->context.Dr7 = dr[7];`
`CHECK (SetThreadContext (th->h, &th->context));`	`CHECK (SetThreadContext (th->h, &th->context));`
`th->context.ContextFlags = 0;`	`th->context.ContextFlags = 0;`
`}`	`}`
`}`	`}`

`debug_registers_changed = 0;`	`debug_registers_changed = 0;`
`return res;`	`return res;`
`}`	`}`

`/* Get the next event from the child. Return 1 if the event requires`	`/* Get the next event from the child. Return 1 if the event requires`
`handling by WFI (or whatever).`	`handling by WFI (or whatever).`
`*/`	`*/`
`static int`	`static int`
`get_child_debug_event (int pid, struct target_waitstatus *ourstatus)`	`get_child_debug_event (int pid, struct target_waitstatus *ourstatus)`
`{`	`{`
`BOOL debug_event;`	`BOOL debug_event;`
`DWORD continue_status, event_code;`	`DWORD continue_status, event_code;`
`thread_info *th = NULL;`	`thread_info *th = NULL;`
`static thread_info dummy_thread_info;`	`static thread_info dummy_thread_info;`
`int retval = 0;`	`int retval = 0;`

`last_sig = TARGET_SIGNAL_0;`	`last_sig = TARGET_SIGNAL_0;`

`if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))`	`if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))`
`goto out;`	`goto out;`

`event_count++;`	`event_count++;`
`continue_status = DBG_CONTINUE;`	`continue_status = DBG_CONTINUE;`

`event_code = current_event.dwDebugEventCode;`	`event_code = current_event.dwDebugEventCode;`
`ourstatus->kind = TARGET_WAITKIND_SPURIOUS;`	`ourstatus->kind = TARGET_WAITKIND_SPURIOUS;`

`switch (event_code)`	`switch (event_code)`
`{`	`{`
`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"CREATE_THREAD_DEBUG_EVENT"));`	`"CREATE_THREAD_DEBUG_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`/* Record the existence of this thread */`	`/* Record the existence of this thread */`
`th = child_add_thread (current_event.dwThreadId,`	`th = 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 (`	`target_pid_to_str (`
`pid_to_ptid (current_event.dwThreadId)));`	`pid_to_ptid (current_event.dwThreadId)));`
`retval = current_event.dwThreadId;`	`retval = 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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"EXIT_THREAD_DEBUG_EVENT"));`	`"EXIT_THREAD_DEBUG_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`child_delete_thread (current_event.dwThreadId);`	`child_delete_thread (current_event.dwThreadId);`
`th = &dummy_thread_info;`	`th = &dummy_thread_info;`
`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"CREATE_PROCESS_DEBUG_EVENT"));`	`"CREATE_PROCESS_DEBUG_EVENT"));`
`CloseHandle (current_event.u.CreateProcessInfo.hFile);`	`CloseHandle (current_event.u.CreateProcessInfo.hFile);`
`if (++saw_create != 1)`	`if (++saw_create != 1)`
`{`	`{`
`CloseHandle (current_event.u.CreateProcessInfo.hProcess);`	`CloseHandle (current_event.u.CreateProcessInfo.hProcess);`
`break;`	`break;`
`}`	`}`

`current_process_handle = current_event.u.CreateProcessInfo.hProcess;`	`current_process_handle = current_event.u.CreateProcessInfo.hProcess;`
`main_thread_id = current_event.dwThreadId;`	`main_thread_id = current_event.dwThreadId;`
`/* Add the main thread */`	`/* Add the main thread */`
`#if 0`	`#if 0`
`th = child_add_thread (current_event.dwProcessId,`	`th = child_add_thread (current_event.dwProcessId,`
`current_event.u.CreateProcessInfo.hProcess);`	`current_event.u.CreateProcessInfo.hProcess);`
`#endif`	`#endif`
`th = child_add_thread (main_thread_id,`	`th = child_add_thread (main_thread_id,`
`current_event.u.CreateProcessInfo.hThread);`	`current_event.u.CreateProcessInfo.hThread);`
`retval = ourstatus->value.related_pid = current_event.dwThreadId;`	`retval = ourstatus->value.related_pid = current_event.dwThreadId;`
`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"EXIT_PROCESS_DEBUG_EVENT"));`	`"EXIT_PROCESS_DEBUG_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`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;`
`CloseHandle (current_process_handle);`	`CloseHandle (current_process_handle);`
`retval = main_thread_id;`	`retval = main_thread_id;`
`break;`	`break;`

`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"LOAD_DLL_DEBUG_EVENT"));`	`"LOAD_DLL_DEBUG_EVENT"));`
`CloseHandle (current_event.u.LoadDll.hFile);`	`CloseHandle (current_event.u.LoadDll.hFile);`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);`	`catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);`
`registers_changed (); /* mark all regs invalid */`	`registers_changed (); /* mark all regs invalid */`
`ourstatus->kind = TARGET_WAITKIND_LOADED;`	`ourstatus->kind = TARGET_WAITKIND_LOADED;`
`ourstatus->value.integer = 0;`	`ourstatus->value.integer = 0;`
`retval = main_thread_id;`	`retval = main_thread_id;`
`re_enable_breakpoints_in_shlibs ();`	`re_enable_breakpoints_in_shlibs ();`
`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"UNLOAD_DLL_DEBUG_EVENT"));`	`"UNLOAD_DLL_DEBUG_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);`	`catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);`
`registers_changed (); /* mark all regs invalid */`	`registers_changed (); /* mark all regs invalid */`
`/* ourstatus->kind = TARGET_WAITKIND_UNLOADED;`	`/* ourstatus->kind = TARGET_WAITKIND_UNLOADED;`
`does not exist yet. */`	`does not exist yet. */`
`break;`	`break;`

`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"EXCEPTION_DEBUG_EVENT"));`	`"EXCEPTION_DEBUG_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`if (handle_exception (ourstatus))`	`if (handle_exception (ourstatus))`
`retval = current_event.dwThreadId;`	`retval = current_event.dwThreadId;`
`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",`
`(unsigned) current_event.dwProcessId,`	`(unsigned) current_event.dwProcessId,`
`(unsigned) current_event.dwThreadId,`	`(unsigned) current_event.dwThreadId,`
`"OUTPUT_DEBUG_STRING_EVENT"));`	`"OUTPUT_DEBUG_STRING_EVENT"));`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`if (handle_output_debug_string (ourstatus))`	`if (handle_output_debug_string (ourstatus))`
`retval = main_thread_id;`	`retval = main_thread_id;`
`break;`	`break;`

`default:`	`default:`
`if (saw_create != 1)`	`if (saw_create != 1)`
`break;`	`break;`
`printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",`	`printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",`
`(DWORD) current_event.dwProcessId,`	`(DWORD) current_event.dwProcessId,`
`(DWORD) current_event.dwThreadId);`	`(DWORD) current_event.dwThreadId);`
`printf_unfiltered (" unknown event code %ld\n",`	`printf_unfiltered (" unknown event code %ld\n",`
`current_event.dwDebugEventCode);`	`current_event.dwDebugEventCode);`
`break;`	`break;`
`}`	`}`

`if (!retval \|\| saw_create != 1)`	`if (!retval \|\| saw_create != 1)`
`CHECK (child_continue (continue_status, -1));`	`CHECK (child_continue (continue_status, -1));`
`else`	`else`
`{`	`{`
`current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);`	`current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);`
`inferior_ptid = pid_to_ptid (retval);`	`inferior_ptid = pid_to_ptid (retval);`
`}`	`}`

`out:`	`out:`
`return retval;`	`return retval;`
`}`	`}`

`/* Wait for interesting events to occur in the target process. */`	`/* Wait for interesting events to occur in the target process. */`
`static ptid_t`	`static ptid_t`
`child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)`	`child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)`
`{`	`{`
`int pid = PIDGET (ptid);`	`int pid = PIDGET (ptid);`

`/* We loop when we get a non-standard exception rather than return`	`/* We loop when we get a non-standard exception rather than return`
`with a SPURIOUS because resume can try and step or modify things,`	`with a SPURIOUS because resume can try and step or modify things,`
`which needs a current_thread->h. But some of these exceptions mark`	`which needs a current_thread->h. But some of these exceptions mark`
`the birth or death of threads, which mean that the current thread`	`the birth or death of threads, which mean that the current thread`
`isn't necessarily what you think it is. */`	`isn't necessarily what you think it is. */`

`while (1)`	`while (1)`
`{`	`{`
`int retval = get_child_debug_event (pid, ourstatus);`	`int retval = get_child_debug_event (pid, ourstatus);`
`if (retval)`	`if (retval)`
`return pid_to_ptid (retval);`	`return pid_to_ptid (retval);`
`else`	`else`
`{`	`{`
`int detach = 0;`	`int detach = 0;`

`if (ui_loop_hook != NULL)`	`if (ui_loop_hook != NULL)`
`detach = ui_loop_hook (0);`	`detach = ui_loop_hook (0);`

`if (detach)`	`if (detach)`
`child_kill_inferior ();`	`child_kill_inferior ();`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`do_initial_child_stuff (DWORD pid)`	`do_initial_child_stuff (DWORD pid)`
`{`	`{`
`extern int stop_after_trap;`	`extern int stop_after_trap;`
`int i;`	`int i;`

`last_sig = TARGET_SIGNAL_0;`	`last_sig = TARGET_SIGNAL_0;`
`event_count = 0;`	`event_count = 0;`
`exception_count = 0;`	`exception_count = 0;`
`debug_registers_changed = 0;`	`debug_registers_changed = 0;`
`debug_registers_used = 0;`	`debug_registers_used = 0;`
`for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)`	`for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)`
`dr[i] = 0;`	`dr[i] = 0;`
`current_event.dwProcessId = pid;`	`current_event.dwProcessId = pid;`
`memset (&current_event, 0, sizeof (current_event));`	`memset (&current_event, 0, sizeof (current_event));`
`push_target (&child_ops);`	`push_target (&child_ops);`
`child_init_thread_list ();`	`child_init_thread_list ();`
`disable_breakpoints_in_shlibs (1);`	`disable_breakpoints_in_shlibs (1);`
`child_clear_solibs ();`	`child_clear_solibs ();`
`clear_proceed_status ();`	`clear_proceed_status ();`
`init_wait_for_inferior ();`	`init_wait_for_inferior ();`

`target_terminal_init ();`	`target_terminal_init ();`
`target_terminal_inferior ();`	`target_terminal_inferior ();`

`while (1)`	`while (1)`
`{`	`{`
`stop_after_trap = 1;`	`stop_after_trap = 1;`
`wait_for_inferior ();`	`wait_for_inferior ();`
`if (stop_signal != TARGET_SIGNAL_TRAP)`	`if (stop_signal != TARGET_SIGNAL_TRAP)`
`resume (0, stop_signal);`	`resume (0, stop_signal);`
`else`	`else`
`break;`	`break;`
`}`	`}`
`stop_after_trap = 0;`	`stop_after_trap = 0;`
`return;`	`return;`
`}`	`}`

`/* Since Windows XP, detaching from a process is supported by Windows.`	`/* Since Windows XP, detaching from a process is supported by Windows.`
`The following code tries loading the appropriate functions dynamically.`	`The following code tries loading the appropriate functions dynamically.`
`If loading these functions succeeds use them to actually detach from`	`If loading these functions succeeds use them to actually detach from`
`the inferior process, otherwise behave as usual, pretending that`	`the inferior process, otherwise behave as usual, pretending that`
`detach has worked. */`	`detach has worked. */`
`static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);`	`static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);`
`static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);`	`static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);`

`static int`	`static int`
`has_detach_ability (void)`	`has_detach_ability (void)`
`{`	`{`
`static HMODULE kernel32 = NULL;`	`static HMODULE kernel32 = NULL;`

`if (!kernel32)`	`if (!kernel32)`
`kernel32 = LoadLibrary ("kernel32.dll");`	`kernel32 = LoadLibrary ("kernel32.dll");`
`if (kernel32)`	`if (kernel32)`
`{`	`{`
`if (!DebugSetProcessKillOnExit)`	`if (!DebugSetProcessKillOnExit)`
`DebugSetProcessKillOnExit = GetProcAddress (kernel32,`	`DebugSetProcessKillOnExit = GetProcAddress (kernel32,`
`"DebugSetProcessKillOnExit");`	`"DebugSetProcessKillOnExit");`
`if (!DebugActiveProcessStop)`	`if (!DebugActiveProcessStop)`
`DebugActiveProcessStop = GetProcAddress (kernel32,`	`DebugActiveProcessStop = GetProcAddress (kernel32,`
`"DebugActiveProcessStop");`	`"DebugActiveProcessStop");`
`if (DebugSetProcessKillOnExit && DebugActiveProcessStop)`	`if (DebugSetProcessKillOnExit && DebugActiveProcessStop)`
`return 1;`	`return 1;`
`}`	`}`
`return 0;`	`return 0;`
`}`	`}`

`/* Attach to process PID, then initialize for debugging it. */`	`/* Attach to process PID, then initialize for debugging it. */`
`static void`	`static void`
`child_attach (char *args, int from_tty)`	`child_attach (char *args, int from_tty)`
`{`	`{`
`BOOL ok;`	`BOOL ok;`
`DWORD pid;`	`DWORD pid;`

`if (!args)`	`if (!args)`
`error_no_arg ("process-id to attach");`	`error_no_arg ("process-id to attach");`

`pid = strtoul (args, 0, 0);`	`pid = strtoul (args, 0, 0);`
`ok = DebugActiveProcess (pid);`	`ok = DebugActiveProcess (pid);`
`saw_create = 0;`	`saw_create = 0;`

`if (!ok)`	`if (!ok)`
`error ("Can't attach to process.");`	`error ("Can't attach to process.");`

`if (has_detach_ability ())`	`if (has_detach_ability ())`
`{`	`{`
`attach_flag = 1;`	`attach_flag = 1;`
`DebugSetProcessKillOnExit (FALSE);`	`DebugSetProcessKillOnExit (FALSE);`
`}`	`}`

`if (from_tty)`	`if (from_tty)`
`{`	`{`
`char exec_file = (char ) get_exec_file (0);`	`char exec_file = (char ) get_exec_file (0);`

`if (exec_file)`	`if (exec_file)`
printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,	printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
`target_pid_to_str (pid_to_ptid (pid)));`	`target_pid_to_str (pid_to_ptid (pid)));`
`else`	`else`
`printf_unfiltered ("Attaching to %s\n",`	`printf_unfiltered ("Attaching to %s\n",`
`target_pid_to_str (pid_to_ptid (pid)));`	`target_pid_to_str (pid_to_ptid (pid)));`

`gdb_flush (gdb_stdout);`	`gdb_flush (gdb_stdout);`
`}`	`}`

`do_initial_child_stuff (pid);`	`do_initial_child_stuff (pid);`
`target_terminal_ours ();`	`target_terminal_ours ();`
`}`	`}`

`static void`	`static void`
`child_detach (char *args, int from_tty)`	`child_detach (char *args, int from_tty)`
`{`	`{`
`int detached = 1;`	`int detached = 1;`

`if (has_detach_ability ())`	`if (has_detach_ability ())`
`{`	`{`
`delete_command (NULL, 0);`	`delete_command (NULL, 0);`
`child_continue (DBG_CONTINUE, -1);`	`child_continue (DBG_CONTINUE, -1);`
`if (!DebugActiveProcessStop (current_event.dwProcessId))`	`if (!DebugActiveProcessStop (current_event.dwProcessId))`
`{`	`{`
`error ("Can't detach process %lu (error %lu)",`	`error ("Can't detach process %lu (error %lu)",`
`current_event.dwProcessId, GetLastError ());`	`current_event.dwProcessId, GetLastError ());`
`detached = 0;`	`detached = 0;`
`}`	`}`
`DebugSetProcessKillOnExit (FALSE);`	`DebugSetProcessKillOnExit (FALSE);`
`}`	`}`
`if (detached && from_tty)`	`if (detached && from_tty)`
`{`	`{`
`char *exec_file = get_exec_file (0);`	`char *exec_file = get_exec_file (0);`
`if (exec_file == 0)`	`if (exec_file == 0)`
`exec_file = "";`	`exec_file = "";`
`printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,`	`printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,`
`current_event.dwProcessId);`	`current_event.dwProcessId);`
`gdb_flush (gdb_stdout);`	`gdb_flush (gdb_stdout);`
`}`	`}`
`inferior_ptid = null_ptid;`	`inferior_ptid = null_ptid;`
`unpush_target (&child_ops);`	`unpush_target (&child_ops);`
`}`	`}`

`/* Print status information about what we're accessing. */`	`/* Print status information about what we're accessing. */`

`static void`	`static void`
`child_files_info (struct target_ops *ignore)`	`child_files_info (struct target_ops *ignore)`
`{`	`{`
`printf_unfiltered ("\tUsing the running image of %s %s.\n",`	`printf_unfiltered ("\tUsing the running image of %s %s.\n",`
`attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));`	`attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));`
`}`	`}`

`/* ARGSUSED */`	`/* ARGSUSED */`
`static void`	`static void`
`child_open (char *arg, int from_tty)`	`child_open (char *arg, int from_tty)`
`{`	`{`
`error ("Use the \"run\" command to start a Unix child process.");`	`error ("Use the \"run\" command to start a Unix child process.");`
`}`	`}`

`/* Start an inferior win32 child process and sets inferior_ptid to its pid.`	`/* Start an inferior win32 child process and sets inferior_ptid to its pid.`
`EXEC_FILE is the file to run.`	`EXEC_FILE is the file to run.`
`ALLARGS is a string containing the arguments to the program.`	`ALLARGS is a string containing the arguments to the program.`
`ENV is the environment vector to pass. Errors reported with error(). */`	`ENV is the environment vector to pass. Errors reported with error(). */`

`static void`	`static void`
`child_create_inferior (char exec_file, char allargs, char **env)`	`child_create_inferior (char exec_file, char allargs, char **env)`
`{`	`{`
`char *winenv;`	`char *winenv;`
`char *temp;`	`char *temp;`
`int envlen;`	`int envlen;`
`int i;`	`int i;`
`STARTUPINFO si;`	`STARTUPINFO si;`
`PROCESS_INFORMATION pi;`	`PROCESS_INFORMATION pi;`
`BOOL ret;`	`BOOL ret;`
`DWORD flags;`	`DWORD flags;`
`char *args;`	`char *args;`
`char real_path[MAXPATHLEN];`	`char real_path[MAXPATHLEN];`
`char *toexec;`	`char *toexec;`
`char shell[MAX_PATH + 1]; /* Path to shell */`	`char shell[MAX_PATH + 1]; /* Path to shell */`
`const char *sh;`	`const char *sh;`

`if (!exec_file)`	`if (!exec_file)`
error ("No executable specified, use `target exec'.\n");	error ("No executable specified, use `target exec'.\n");

`memset (&si, 0, sizeof (si));`	`memset (&si, 0, sizeof (si));`
`si.cb = sizeof (si);`	`si.cb = sizeof (si);`

`if (!useshell)`	`if (!useshell)`
`{`	`{`
`flags = DEBUG_ONLY_THIS_PROCESS;`	`flags = DEBUG_ONLY_THIS_PROCESS;`
`cygwin_conv_to_win32_path (exec_file, real_path);`	`cygwin_conv_to_win32_path (exec_file, real_path);`
`toexec = real_path;`	`toexec = real_path;`
`}`	`}`
`else`	`else`
`{`	`{`
`char *newallargs;`	`char *newallargs;`
`sh = getenv ("SHELL");`	`sh = getenv ("SHELL");`
`if (!sh)`	`if (!sh)`
`sh = "/bin/sh";`	`sh = "/bin/sh";`
`cygwin_conv_to_win32_path (sh, shell);`	`cygwin_conv_to_win32_path (sh, shell);`
`newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)`	`newallargs = alloca (sizeof (" -c 'exec '") + strlen (exec_file)`
`+ strlen (allargs) + 2);`	`+ strlen (allargs) + 2);`
`sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);`	`sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);`
`allargs = newallargs;`	`allargs = newallargs;`
`toexec = shell;`	`toexec = shell;`
`flags = DEBUG_PROCESS;`	`flags = DEBUG_PROCESS;`
`}`	`}`

`if (new_group)`	`if (new_group)`
`flags \|= CREATE_NEW_PROCESS_GROUP;`	`flags \|= CREATE_NEW_PROCESS_GROUP;`

`if (new_console)`	`if (new_console)`
`flags \|= CREATE_NEW_CONSOLE;`	`flags \|= CREATE_NEW_CONSOLE;`

`args = alloca (strlen (toexec) + strlen (allargs) + 2);`	`args = alloca (strlen (toexec) + strlen (allargs) + 2);`
`strcpy (args, toexec);`	`strcpy (args, toexec);`
`strcat (args, " ");`	`strcat (args, " ");`
`strcat (args, allargs);`	`strcat (args, allargs);`

`/* Prepare the environment vars for CreateProcess. */`	`/* Prepare the environment vars for CreateProcess. */`
`{`	`{`
`/* This code used to assume all env vars were file names and would`	`/* This code used to assume all env vars were file names and would`
`translate them all to win32 style. That obviously doesn't work in the`	`translate them all to win32 style. That obviously doesn't work in the`
`general case. The current rule is that we only translate PATH.`	`general case. The current rule is that we only translate PATH.`
`We need to handle PATH because we're about to call CreateProcess and`	`We need to handle PATH because we're about to call CreateProcess and`
`it uses PATH to find DLL's. Fortunately PATH has a well-defined value`	`it uses PATH to find DLL's. Fortunately PATH has a well-defined value`
`in both posix and win32 environments. cygwin.dll will change it back`	`in both posix and win32 environments. cygwin.dll will change it back`
`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). */`

`/* Get total size for env strings. */`	`/* Get total size for env strings. */`
`for (envlen = 0, i = 0; env[i] && *env[i]; i++)`	`for (envlen = 0, i = 0; env[i] && *env[i]; i++)`
`{`	`{`
`int j, len;`	`int j, len;`

`for (j = 0; conv_path_names[j]; j++)`	`for (j = 0; conv_path_names[j]; j++)`
`{`	`{`
`len = strlen (conv_path_names[j]);`	`len = strlen (conv_path_names[j]);`
`if (strncmp (conv_path_names[j], env[i], len) == 0)`	`if (strncmp (conv_path_names[j], env[i], len) == 0)`
`{`	`{`
`if (cygwin_posix_path_list_p (env[i] + len))`	`if (cygwin_posix_path_list_p (env[i] + len))`
`envlen += len`	`envlen += len`
`+ cygwin_posix_to_win32_path_list_buf_size (env[i] + len);`	`+ cygwin_posix_to_win32_path_list_buf_size (env[i] + len);`
`else`	`else`
`envlen += strlen (env[i]) + 1;`	`envlen += strlen (env[i]) + 1;`
`break;`	`break;`
`}`	`}`
`}`	`}`
`if (conv_path_names[j] == NULL)`	`if (conv_path_names[j] == NULL)`
`envlen += strlen (env[i]) + 1;`	`envlen += strlen (env[i]) + 1;`
`}`	`}`

`winenv = alloca (envlen + 1);`	`winenv = alloca (envlen + 1);`

`/* Copy env strings into new buffer. */`	`/* Copy env strings into new buffer. */`
`for (temp = winenv, i = 0; env[i] && *env[i]; i++)`	`for (temp = winenv, i = 0; env[i] && *env[i]; i++)`
`{`	`{`
`int j, len;`	`int j, len;`

`for (j = 0; conv_path_names[j]; j++)`	`for (j = 0; conv_path_names[j]; j++)`
`{`	`{`
`len = strlen (conv_path_names[j]);`	`len = strlen (conv_path_names[j]);`
`if (strncmp (conv_path_names[j], env[i], len) == 0)`	`if (strncmp (conv_path_names[j], env[i], len) == 0)`
`{`	`{`
`if (cygwin_posix_path_list_p (env[i] + len))`	`if (cygwin_posix_path_list_p (env[i] + len))`
`{`	`{`
`memcpy (temp, env[i], len);`	`memcpy (temp, env[i], len);`
`cygwin_posix_to_win32_path_list (env[i] + len, temp + len);`	`cygwin_posix_to_win32_path_list (env[i] + len, temp + len);`
`}`	`}`
`else`	`else`
`strcpy (temp, env[i]);`	`strcpy (temp, env[i]);`
`break;`	`break;`
`}`	`}`
`}`	`}`
`if (conv_path_names[j] == NULL)`	`if (conv_path_names[j] == NULL)`
`strcpy (temp, env[i]);`	`strcpy (temp, env[i]);`

`temp += strlen (temp) + 1;`	`temp += strlen (temp) + 1;`
`}`	`}`

`/* Final nil string to terminate new env. */`	`/* Final nil string to terminate new env. */`
`*temp = 0;`	`*temp = 0;`
`}`	`}`

`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 */`
`flags, /* start flags */`	`flags, /* start flags */`
`winenv,`	`winenv,`
`NULL, /* current directory */`	`NULL, /* current directory */`
`&si,`	`&si,`
`&pi);`	`&pi);`
`if (!ret)`	`if (!ret)`
`error ("Error creating process %s, (error %d)\n", exec_file, (unsigned) GetLastError ());`	`error ("Error creating process %s, (error %d)\n", exec_file, (unsigned) GetLastError ());`

`CloseHandle (pi.hThread);`	`CloseHandle (pi.hThread);`
`CloseHandle (pi.hProcess);`	`CloseHandle (pi.hProcess);`

`if (useshell && shell[0] != '\0')`	`if (useshell && shell[0] != '\0')`
`saw_create = -1;`	`saw_create = -1;`
`else`	`else`
`saw_create = 0;`	`saw_create = 0;`

`do_initial_child_stuff (pi.dwProcessId);`	`do_initial_child_stuff (pi.dwProcessId);`

`/* child_continue (DBG_CONTINUE, -1); */`	`/* child_continue (DBG_CONTINUE, -1); */`
`proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);`	`proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);`
`}`	`}`

`static void`	`static void`
`child_mourn_inferior (void)`	`child_mourn_inferior (void)`
`{`	`{`
`(void) child_continue (DBG_CONTINUE, -1);`	`(void) child_continue (DBG_CONTINUE, -1);`
`i386_cleanup_dregs();`	`i386_cleanup_dregs();`
`unpush_target (&child_ops);`	`unpush_target (&child_ops);`
`generic_mourn_inferior ();`	`generic_mourn_inferior ();`
`}`	`}`

`/* Send a SIGINT to the process group. This acts just like the user typed a`	`/* Send a SIGINT to the process group. This acts just like the user typed a`
`^C on the controlling terminal. */`	`^C on the controlling terminal. */`

`static void`	`static void`
`child_stop (void)`	`child_stop (void)`
`{`	`{`
`DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));`	`DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));`
`CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));`	`CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));`
`registers_changed (); /* refresh register state */`	`registers_changed (); /* refresh register state */`
`}`	`}`

`int`	`int`
`child_xfer_memory (CORE_ADDR memaddr, char *our, int len,`	`child_xfer_memory (CORE_ADDR memaddr, char *our, int len,`
`int write, struct mem_attrib *mem,`	`int write, struct mem_attrib *mem,`
`struct target_ops *target)`	`struct target_ops *target)`
`{`	`{`
`DWORD done;`	`DWORD done;`
`if (write)`	`if (write)`
`{`	`{`
`DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",`	`DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",`
`len, (DWORD) memaddr));`	`len, (DWORD) memaddr));`
`WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,`	`WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,`
`len, &done);`	`len, &done);`
`FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);`	`FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);`
`}`	`}`
`else`	`else`
`{`	`{`
`DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",`	`DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",`
`len, (DWORD) memaddr));`	`len, (DWORD) memaddr));`
`ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our, len,`	`ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our, len,`
`&done);`	`&done);`
`}`	`}`
`return done;`	`return done;`
`}`	`}`

`void`	`void`
`child_kill_inferior (void)`	`child_kill_inferior (void)`
`{`	`{`
`CHECK (TerminateProcess (current_process_handle, 0));`	`CHECK (TerminateProcess (current_process_handle, 0));`

`for (;;)`	`for (;;)`
`{`	`{`
`if (!child_continue (DBG_CONTINUE, -1))`	`if (!child_continue (DBG_CONTINUE, -1))`
`break;`	`break;`
`if (!WaitForDebugEvent (&current_event, INFINITE))`	`if (!WaitForDebugEvent (&current_event, INFINITE))`
`break;`	`break;`
`if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)`	`if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)`
`break;`	`break;`
`}`	`}`

`CHECK (CloseHandle (current_process_handle));`	`CHECK (CloseHandle (current_process_handle));`

`/* 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`
`child_resume (ptid_t ptid, int step, enum target_signal sig)`	`child_resume (ptid_t ptid, int step, enum target_signal sig)`
`{`	`{`
`thread_info *th;`	`thread_info *th;`
`DWORD continue_status = DBG_CONTINUE;`	`DWORD continue_status = DBG_CONTINUE;`

`int pid = PIDGET (ptid);`	`int pid = PIDGET (ptid);`

`if (sig != TARGET_SIGNAL_0)`	`if (sig != TARGET_SIGNAL_0)`
`{`	`{`
`if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)`	`if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)`
`{`	`{`
`DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));`	`DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));`
`}`	`}`
`else if (sig == last_sig)`	`else if (sig == last_sig)`
`continue_status = DBG_EXCEPTION_NOT_HANDLED;`	`continue_status = DBG_EXCEPTION_NOT_HANDLED;`
`else`	`else`
`#if 0`	`#if 0`
`/* This code does not seem to work, because`	`/* This code does not seem to work, because`
`the kernel does probably not consider changes in the ExceptionRecord`	`the kernel does probably not consider changes in the ExceptionRecord`
`structure when passing the exception to the inferior.`	`structure when passing the exception to the inferior.`
`Note that this seems possible in the exception handler itself. */`	`Note that this seems possible in the exception handler itself. */`
`{`	`{`
`int i;`	`int i;`
`for (i = 0; xlate[i].them != -1; i++)`	`for (i = 0; xlate[i].them != -1; i++)`
`if (xlate[i].us == sig)`	`if (xlate[i].us == sig)`
`{`	`{`
`current_event.u.Exception.ExceptionRecord.ExceptionCode =`	`current_event.u.Exception.ExceptionRecord.ExceptionCode =`
`xlate[i].them;`	`xlate[i].them;`
`continue_status = DBG_EXCEPTION_NOT_HANDLED;`	`continue_status = DBG_EXCEPTION_NOT_HANDLED;`
`break;`	`break;`
`}`	`}`
`if (continue_status == DBG_CONTINUE)`	`if (continue_status == DBG_CONTINUE)`
`{`	`{`
`DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));`	`DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));`
`}`	`}`
`}`	`}`
`#endif`	`#endif`
`DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",`	`DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",`
`last_sig));`	`last_sig));`
`}`	`}`

`last_sig = TARGET_SIGNAL_0;`	`last_sig = TARGET_SIGNAL_0;`

`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));`

`/* Get context for currently selected thread */`	`/* Get context for currently selected thread */`
`th = thread_rec (current_event.dwThreadId, FALSE);`	`th = thread_rec (current_event.dwThreadId, FALSE);`
`if (th)`	`if (th)`
`{`	`{`
`if (step)`	`if (step)`
`{`	`{`
`/* Single step by setting t bit */`	`/* Single step by setting t bit */`
`child_fetch_inferior_registers (PS_REGNUM);`	`child_fetch_inferior_registers (PS_REGNUM);`
`th->context.EFlags \|= FLAG_TRACE_BIT;`	`th->context.EFlags \|= FLAG_TRACE_BIT;`
`}`	`}`

`if (th->context.ContextFlags)`	`if (th->context.ContextFlags)`
`{`	`{`
`if (debug_registers_changed)`	`if (debug_registers_changed)`
`{`	`{`
`th->context.Dr0 = dr[0];`	`th->context.Dr0 = dr[0];`
`th->context.Dr1 = dr[1];`	`th->context.Dr1 = dr[1];`
`th->context.Dr2 = dr[2];`	`th->context.Dr2 = dr[2];`
`th->context.Dr3 = dr[3];`	`th->context.Dr3 = dr[3];`
`/* th->context.Dr6 = dr[6];`	`/* th->context.Dr6 = dr[6];`
`FIXME: should we set dr6 also ?? */`	`FIXME: should we set dr6 also ?? */`
`th->context.Dr7 = dr[7];`	`th->context.Dr7 = dr[7];`
`}`	`}`
`CHECK (SetThreadContext (th->h, &th->context));`	`CHECK (SetThreadContext (th->h, &th->context));`
`th->context.ContextFlags = 0;`	`th->context.ContextFlags = 0;`
`}`	`}`
`}`	`}`

`/* Allow continuing with the same signal that interrupted us.`	`/* Allow continuing with the same signal that interrupted us.`
`Otherwise complain. */`	`Otherwise complain. */`

`child_continue (continue_status, pid);`	`child_continue (continue_status, pid);`
`}`	`}`

`static void`	`static void`
`child_prepare_to_store (void)`	`child_prepare_to_store (void)`
`{`	`{`
`/* Do nothing, since we can store individual regs */`	`/* Do nothing, since we can store individual regs */`
`}`	`}`

`static int`	`static int`
`child_can_run (void)`	`child_can_run (void)`
`{`	`{`
`return 1;`	`return 1;`
`}`	`}`

`static void`	`static void`
`child_close (int x)`	`child_close (int x)`
`{`	`{`
`DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",`	`DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",`
`PIDGET (inferior_ptid)));`	`PIDGET (inferior_ptid)));`
`}`	`}`

`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_save_ours = terminal_save_ours;`	`child_ops.to_terminal_save_ours = terminal_save_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_pid_to_str = cygwin_pid_to_str;`	`child_ops.to_pid_to_str = cygwin_pid_to_str;`
`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_win32_nat (void)`	`_initialize_win32_nat (void)`
`{`	`{`
`struct cmd_list_element *c;`	`struct cmd_list_element *c;`

`init_child_ops ();`	`init_child_ops ();`

`c = add_com ("dll-symbols", class_files, dll_symbol_command,`	`c = add_com ("dll-symbols", class_files, dll_symbol_command,`
`"Load dll library symbols from FILE.");`	`"Load dll library symbols from FILE.");`
`set_cmd_completer (c, filename_completer);`	`set_cmd_completer (c, filename_completer);`

`add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);`	`add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);`

`add_show_from_set (add_set_cmd ("shell", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("shell", class_support, var_boolean,`
`(char *) &useshell,`	`(char *) &useshell,`
`"Set use of shell to start subprocess.",`	`"Set use of shell to start subprocess.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,`
`(char *) &new_console,`	`(char *) &new_console,`
`"Set creation of new console when creating child process.",`	`"Set creation of new console when creating child process.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,`
`(char *) &new_group,`	`(char *) &new_group,`
`"Set creation of new group when creating child process.",`	`"Set creation of new group when creating child process.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,`
`(char *) &debug_exec,`	`(char *) &debug_exec,`
`"Set whether to display execution in child process.",`	`"Set whether to display execution in child process.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,`
`(char *) &debug_events,`	`(char *) &debug_events,`
`"Set whether to display kernel events in child process.",`	`"Set whether to display kernel events in child process.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,`	`add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,`
`(char *) &debug_memory,`	`(char *) &debug_memory,`
`"Set whether to display memory accesses in child process.",`	`"Set whether to display memory accesses in child process.",`
`&setlist),`	`&setlist),`
`&showlist);`	`&showlist);`

`add_show_from_set (add_set_cmd ("debugexceptions", class_support, var_boolean,`	`add_show_from_set (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);`

`add_info ("dll", info_dll_command, "Status of loaded DLLs.");`	`add_info ("dll", info_dll_command, "Status of loaded DLLs.");`
`add_info_alias ("sharedlibrary", "dll", 1);`	`add_info_alias ("sharedlibrary", "dll", 1);`

`add_prefix_cmd ("w32", class_info, info_w32_command,`	`add_prefix_cmd ("w32", class_info, info_w32_command,`
`"Print information specific to Win32 debugging.",`	`"Print information specific to Win32 debugging.",`
`&info_w32_cmdlist, "info w32 ", 0, &infolist);`	`&info_w32_cmdlist, "info w32 ", 0, &infolist);`

`add_cmd ("selector", class_info, display_selectors,`	`add_cmd ("selector", class_info, display_selectors,`
`"Display selectors infos.",`	`"Display selectors infos.",`
`&info_w32_cmdlist);`	`&info_w32_cmdlist);`

`add_target (&child_ops);`	`add_target (&child_ops);`
`}`	`}`

`/* Hardware watchpoint support, adapted from go32-nat.c code. */`	`/* Hardware watchpoint support, adapted from go32-nat.c code. */`

`/* Pass the address ADDR to the inferior in the I'th debug register.`	`/* Pass the address ADDR to the inferior in the I'th debug register.`
`Here we just store the address in dr array, the registers will be`	`Here we just store the address in dr array, the registers will be`
`actually set up when child_continue is called. */`	`actually set up when child_continue is called. */`
`void`	`void`
`cygwin_set_dr (int i, CORE_ADDR addr)`	`cygwin_set_dr (int i, CORE_ADDR addr)`
`{`	`{`
`if (i < 0 \|\| i > 3)`	`if (i < 0 \|\| i > 3)`
`internal_error (__FILE__, __LINE__,`	`internal_error (__FILE__, __LINE__,`
`"Invalid register %d in cygwin_set_dr.\n", i);`	`"Invalid register %d in cygwin_set_dr.\n", i);`
`dr[i] = (unsigned) addr;`	`dr[i] = (unsigned) addr;`
`debug_registers_changed = 1;`	`debug_registers_changed = 1;`
`debug_registers_used = 1;`	`debug_registers_used = 1;`
`}`	`}`

`/* Pass the value VAL to the inferior in the DR7 debug control`	`/* Pass the value VAL to the inferior in the DR7 debug control`
`register. Here we just store the address in D_REGS, the watchpoint`	`register. Here we just store the address in D_REGS, the watchpoint`
`will be actually set up in child_wait. */`	`will be actually set up in child_wait. */`
`void`	`void`
`cygwin_set_dr7 (unsigned val)`	`cygwin_set_dr7 (unsigned val)`
`{`	`{`
`dr[7] = val;`	`dr[7] = val;`
`debug_registers_changed = 1;`	`debug_registers_changed = 1;`
`debug_registers_used = 1;`	`debug_registers_used = 1;`
`}`	`}`

`/* Get the value of the DR6 debug status register from the inferior.`	`/* Get the value of the DR6 debug status register from the inferior.`
`Here we just return the value stored in dr[6]`	`Here we just return the value stored in dr[6]`
`by the last call to thread_rec for current_event.dwThreadId id. */`	`by the last call to thread_rec for current_event.dwThreadId id. */`
`unsigned`	`unsigned`
`cygwin_get_dr6 (void)`	`cygwin_get_dr6 (void)`
`{`	`{`
`return dr[6];`	`return dr[6];`
`}`	`}`


`/* Determine if the thread referenced by "pid" is alive`	`/* Determine if the thread referenced by "pid" is alive`
`by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0`	`by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0`
`it means that the pid has died. Otherwise it is assumed to be alive. */`	`it means that the pid has died. Otherwise it is assumed to be alive. */`
`static int`	`static int`
`win32_child_thread_alive (ptid_t ptid)`	`win32_child_thread_alive (ptid_t ptid)`
`{`	`{`
`int pid = PIDGET (ptid);`	`int pid = PIDGET (ptid);`

`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. */`
`char *`	`char *`
`cygwin_pid_to_str (ptid_t ptid)`	`cygwin_pid_to_str (ptid_t ptid)`
`{`	`{`
`static char buf[80];`	`static char buf[80];`
`int pid = PIDGET (ptid);`	`int pid = PIDGET (ptid);`

`if ((DWORD) pid == current_event.dwProcessId)`	`if ((DWORD) pid == current_event.dwProcessId)`
`sprintf (buf, "process %d", pid);`	`sprintf (buf, "process %d", pid);`
`else`	`else`
`sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);`	`sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);`
`return buf;`	`return buf;`
`}`	`}`

`static int`	`static int`
`core_dll_symbols_add (char *dll_name, DWORD base_addr)`	`core_dll_symbols_add (char *dll_name, DWORD base_addr)`
`{`	`{`
`struct objfile *objfile;`	`struct objfile *objfile;`
`char *objfile_basename;`	`char *objfile_basename;`
`const char *dll_basename;`	`const char *dll_basename;`

`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)`
`{`	`{`
`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 ("%08lx:%s (symbols previously loaded)\n",`	`printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",`
`base_addr, dll_name);`	`base_addr, dll_name);`
`goto out;`	`goto out;`
`}`	`}`
`}`	`}`

`register_loaded_dll (dll_name, base_addr + 0x1000);`	`register_loaded_dll (dll_name, base_addr + 0x1000);`
`solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);`	`solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);`

`out:`	`out:`
`return 1;`	`return 1;`
`}`	`}`

`typedef struct`	`typedef struct`
`{`	`{`
`struct target_ops *target;`	`struct target_ops *target;`
`bfd_vma addr;`	`bfd_vma addr;`
`}`	`}`
`map_code_section_args;`	`map_code_section_args;`

`static void`	`static void`
`map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)`	`map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)`
`{`	`{`
`int old;`	`int old;`
`int update_coreops;`	`int update_coreops;`
`struct section_table *new_target_sect_ptr;`	`struct section_table *new_target_sect_ptr;`

`map_code_section_args args = (map_code_section_args ) obj;`	`map_code_section_args args = (map_code_section_args ) obj;`
`struct target_ops *target = args->target;`	`struct target_ops *target = args->target;`
`if (sect->flags & SEC_CODE)`	`if (sect->flags & SEC_CODE)`
`{`	`{`
`update_coreops = core_ops.to_sections == target->to_sections;`	`update_coreops = core_ops.to_sections == target->to_sections;`

`if (target->to_sections)`	`if (target->to_sections)`
`{`	`{`
`old = target->to_sections_end - target->to_sections;`	`old = target->to_sections_end - target->to_sections;`
`target->to_sections = (struct section_table *)`	`target->to_sections = (struct section_table *)`
`xrealloc ((char *) target->to_sections,`	`xrealloc ((char *) target->to_sections,`
`(sizeof (struct section_table)) * (1 + old));`	`(sizeof (struct section_table)) * (1 + old));`
`}`	`}`
`else`	`else`
`{`	`{`
`old = 0;`	`old = 0;`
`target->to_sections = (struct section_table *)`	`target->to_sections = (struct section_table *)`
`xmalloc ((sizeof (struct section_table)));`	`xmalloc ((sizeof (struct section_table)));`
`}`	`}`
`target->to_sections_end = target->to_sections + (1 + old);`	`target->to_sections_end = target->to_sections + (1 + old);`

`/* Update the to_sections field in the core_ops structure`	`/* Update the to_sections field in the core_ops structure`
`if needed. */`	`if needed. */`
`if (update_coreops)`	`if (update_coreops)`
`{`	`{`
`core_ops.to_sections = target->to_sections;`	`core_ops.to_sections = target->to_sections;`
`core_ops.to_sections_end = target->to_sections_end;`	`core_ops.to_sections_end = target->to_sections_end;`
`}`	`}`
`new_target_sect_ptr = target->to_sections + old;`	`new_target_sect_ptr = target->to_sections + old;`
`new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);`	`new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);`
`new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +`	`new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +`
`bfd_section_size (abfd, sect);;`	`bfd_section_size (abfd, sect);;`
`new_target_sect_ptr->the_bfd_section = sect;`	`new_target_sect_ptr->the_bfd_section = sect;`
`new_target_sect_ptr->bfd = abfd;`	`new_target_sect_ptr->bfd = abfd;`
`}`	`}`
`}`	`}`

`static int`	`static int`
`dll_code_sections_add (const char dll_name, int base_addr, struct target_ops target)`	`dll_code_sections_add (const char dll_name, int base_addr, struct target_ops target)`
`{`	`{`
`bfd *dll_bfd;`	`bfd *dll_bfd;`
`map_code_section_args map_args;`	`map_code_section_args map_args;`
`asection *lowest_sect;`	`asection *lowest_sect;`
`char *name;`	`char *name;`
`if (dll_name == NULL \|\| target == NULL)`	`if (dll_name == NULL \|\| target == NULL)`
`return 0;`	`return 0;`
`name = xstrdup (dll_name);`	`name = xstrdup (dll_name);`
`dll_bfd = bfd_openr (name, "pei-i386");`	`dll_bfd = bfd_openr (name, "pei-i386");`
`if (dll_bfd == NULL)`	`if (dll_bfd == NULL)`
`return 0;`	`return 0;`

`if (bfd_check_format (dll_bfd, bfd_object))`	`if (bfd_check_format (dll_bfd, bfd_object))`
`{`	`{`
`lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");`	`lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");`
`if (lowest_sect == NULL)`	`if (lowest_sect == NULL)`
`return 0;`	`return 0;`
`map_args.target = target;`	`map_args.target = target;`
`map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);`	`map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);`

`bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));`	`bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));`
`}`	`}`

`return 1;`	`return 1;`
`}`	`}`

`static void`	`static void`
`core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)`	`core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)`
`{`	`{`
`struct target_ops target = (struct target_ops ) obj;`	`struct target_ops target = (struct target_ops ) obj;`

`DWORD base_addr;`	`DWORD base_addr;`

`int dll_name_size;`	`int dll_name_size;`
`char *dll_name = NULL;`	`char *dll_name = NULL;`
`char *buf = NULL;`	`char *buf = NULL;`
`struct win32_pstatus *pstatus;`	`struct win32_pstatus *pstatus;`
`char *p;`	`char *p;`

`if (strncmp (sect->name, ".module", 7))`	`if (strncmp (sect->name, ".module", 7))`
`return;`	`return;`

`buf = (char *) xmalloc (sect->_raw_size + 1);`	`buf = (char *) xmalloc (sect->_raw_size + 1);`
`if (!buf)`	`if (!buf)`
`{`	`{`
`printf_unfiltered ("memory allocation failed for %s\n", sect->name);`	`printf_unfiltered ("memory allocation failed for %s\n", sect->name);`
`goto out;`	`goto out;`
`}`	`}`
`if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))`	`if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))`
`goto out;`	`goto out;`

`pstatus = (struct win32_pstatus *) buf;`	`pstatus = (struct win32_pstatus *) buf;`

`memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));`	`memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));`
`dll_name_size = pstatus->data.module_info.module_name_size;`	`dll_name_size = pstatus->data.module_info.module_name_size;`
`if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)`	`if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)`
`goto out;`	`goto out;`

`dll_name = (char *) xmalloc (dll_name_size + 1);`	`dll_name = (char *) xmalloc (dll_name_size + 1);`
`if (!dll_name)`	`if (!dll_name)`
`{`	`{`
`printf_unfiltered ("memory allocation failed for %s\n", sect->name);`	`printf_unfiltered ("memory allocation failed for %s\n", sect->name);`
`goto out;`	`goto out;`
`}`	`}`
`strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);`	`strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);`

`while ((p = strchr (dll_name, '\\')))`	`while ((p = strchr (dll_name, '\\')))`
`*p = '/';`	`*p = '/';`

`if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))`	`if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))`
`printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);`	`printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);`

`if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))`	`if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))`
`printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);`	`printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);`

`out:`	`out:`
`if (buf)`	`if (buf)`
`xfree (buf);`	`xfree (buf);`
`if (dll_name)`	`if (dll_name)`
`xfree (dll_name);`	`xfree (dll_name);`
`return;`	`return;`
`}`	`}`

`void`	`void`
`child_solib_add (char filename, int from_tty, struct target_ops target,`	`child_solib_add (char filename, int from_tty, struct target_ops target,`
`int readsyms)`	`int readsyms)`
`{`	`{`
`if (!readsyms)`	`if (!readsyms)`
`return;`	`return;`
`if (core_bfd)`	`if (core_bfd)`
`{`	`{`
`child_clear_solibs ();`	`child_clear_solibs ();`
`bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);`	`bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);`
`}`	`}`
`else`	`else`
`{`	`{`
`if (solib_end && solib_end->name)`	`if (solib_end && solib_end->name)`
`solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,`	`solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,`
`solib_end->load_addr);`	`solib_end->load_addr);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`fetch_elf_core_registers (char *core_reg_sect,`	`fetch_elf_core_registers (char *core_reg_sect,`
`unsigned core_reg_size,`	`unsigned core_reg_size,`
`int which,`	`int which,`
`CORE_ADDR reg_addr)`	`CORE_ADDR reg_addr)`
`{`	`{`
`int r;`	`int r;`
`if (core_reg_size < sizeof (CONTEXT))`	`if (core_reg_size < sizeof (CONTEXT))`
`{`	`{`
`error ("Core file register section too small (%u bytes).", core_reg_size);`	`error ("Core file register section too small (%u bytes).", core_reg_size);`
`return;`	`return;`
`}`	`}`
`for (r = 0; r < NUM_REGS; r++)`	`for (r = 0; r < NUM_REGS; r++)`
`supply_register (r, core_reg_sect + mappings[r]);`	`supply_register (r, core_reg_sect + mappings[r]);`
`}`	`}`

`static struct core_fns win32_elf_core_fns =`	`static struct core_fns win32_elf_core_fns =`
`{`	`{`
`bfd_target_elf_flavour,`	`bfd_target_elf_flavour,`
`default_check_format,`	`default_check_format,`
`default_core_sniffer,`	`default_core_sniffer,`
`fetch_elf_core_registers,`	`fetch_elf_core_registers,`
`NULL`	`NULL`
`};`	`};`

`void`	`void`
`_initialize_core_win32 (void)`	`_initialize_core_win32 (void)`
`{`	`{`
`add_core_fns (&win32_elf_core_fns);`	`add_core_fns (&win32_elf_core_fns);`
`}`	`}`

`void`	`void`
`_initialize_check_for_gdb_ini (void)`	`_initialize_check_for_gdb_ini (void)`
`{`	`{`
`char *homedir;`	`char *homedir;`
`if (inhibit_gdbinit)`	`if (inhibit_gdbinit)`
`return;`	`return;`

`homedir = getenv ("HOME");`	`homedir = getenv ("HOME");`
`if (homedir)`	`if (homedir)`
`{`	`{`
`char *p;`	`char *p;`
`char oldini = (char ) alloca (strlen (homedir) +`	`char oldini = (char ) alloca (strlen (homedir) +`
`sizeof ("/gdb.ini"));`	`sizeof ("/gdb.ini"));`
`strcpy (oldini, homedir);`	`strcpy (oldini, homedir);`
`p = strchr (oldini, '\0');`	`p = strchr (oldini, '\0');`
`if (p > oldini && p[-1] != '/')`	`if (p > oldini && p[-1] != '/')`
`*p++ = '/';`	`*p++ = '/';`
`strcpy (p, "gdb.ini");`	`strcpy (p, "gdb.ini");`
`if (access (oldini, 0) == 0)`	`if (access (oldini, 0) == 0)`
`{`	`{`
`int len = strlen (oldini);`	`int len = strlen (oldini);`
`char *newini = alloca (len + 1);`	`char *newini = alloca (len + 1);`
`sprintf (newini, "%.*s.gdbinit",`	`sprintf (newini, "%.*s.gdbinit",`
`(int) (len - (sizeof ("gdb.ini") - 1)), oldini);`	`(int) (len - (sizeof ("gdb.ini") - 1)), oldini);`
`warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);`	`warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);`
`}`	`}`
`}`	`}`
`}`	`}`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [win32-nat.c] - Diff between revs 1181 and 1765