X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fwindows-nat.c;h=67f0c99599a9779bfa5a5c5c33498adf76bba81d;hb=727fc41e077139570ea8b8ddfd6c546b2a55627c;hp=8365cba0630f63f77fa3cc3a17b5d98519c1abd1;hpb=d6b48e9c8beee5d3ab78ac1979f6af0d6de9ae30;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c index 8365cba063..67f0c99599 100644 --- a/gdb/windows-nat.c +++ b/gdb/windows-nat.c @@ -1,7 +1,7 @@ -/* Target-vector operations for controlling win32 child processes, for GDB. +/* Target-vector operations for controlling windows child processes, for GDB. Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, - 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by Cygnus Solutions, A Red Hat Company. @@ -60,14 +60,15 @@ #include "i386-tdep.h" #include "i387-tdep.h" -#include "i386-cygwin-tdep.h" +#include "windows-tdep.h" +#include "windows-nat.h" -static struct target_ops win32_ops; +static struct target_ops windows_ops; #ifdef __CYGWIN__ /* The starting and ending address of the cygwin1.dll text segment. */ -static bfd_vma cygwin_load_start; -static bfd_vma cygwin_load_end; +static CORE_ADDR cygwin_load_start; +static CORE_ADDR cygwin_load_end; #endif static int have_saved_context; /* True if we've saved context from a cygwin signal. */ @@ -85,6 +86,12 @@ enum #endif #include +#ifndef CONTEXT_EXTENDED_REGISTERS +/* This macro is only defined on ia32. It only makes sense on this target, + so define it as zero if not already defined. */ +#define CONTEXT_EXTENDED_REGISTERS 0 +#endif + #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \ | CONTEXT_EXTENDED_REGISTERS @@ -105,9 +112,9 @@ static int debug_registers_used; #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x -static void win32_stop (ptid_t); -static int win32_win32_thread_alive (ptid_t); -static void win32_kill_inferior (void); +static void windows_stop (ptid_t); +static int windows_thread_alive (struct target_ops *, ptid_t); +static void windows_kill_inferior (void); static enum target_signal last_sig = TARGET_SIGNAL_0; /* Set if a signal was received from the debugged process */ @@ -155,11 +162,16 @@ static int debug_memory = 0; /* show target memory accesses */ static int debug_exceptions = 0; /* show target exceptions */ static int useshell = 0; /* use shell for subprocesses */ -/* This vector maps GDB's idea of a register's number into an address - in the win32 exception context vector. +/* This vector maps GDB's idea of a register's number into an offset + in the windows exception context vector. It also contains the bit mask needed to load the register in question. + The contents of this table can only be computed by the units + that provide CPU-specific support for Windows native debugging. + These units should set the table by calling + windows_set_context_register_offsets. + 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, we read that set of registers in using GetThreadContext. If the @@ -168,55 +180,7 @@ static int useshell = 0; /* use shell for subprocesses */ the other regs of the group, and then we copy the info in and set out bit. */ -#define context_offset(x) ((int)&(((CONTEXT *)NULL)->x)) -static const int mappings[] = -{ - context_offset (Eax), - context_offset (Ecx), - context_offset (Edx), - context_offset (Ebx), - context_offset (Esp), - context_offset (Ebp), - context_offset (Esi), - context_offset (Edi), - context_offset (Eip), - context_offset (EFlags), - context_offset (SegCs), - context_offset (SegSs), - context_offset (SegDs), - context_offset (SegEs), - context_offset (SegFs), - context_offset (SegGs), - context_offset (FloatSave.RegisterArea[0 * 10]), - context_offset (FloatSave.RegisterArea[1 * 10]), - context_offset (FloatSave.RegisterArea[2 * 10]), - context_offset (FloatSave.RegisterArea[3 * 10]), - context_offset (FloatSave.RegisterArea[4 * 10]), - context_offset (FloatSave.RegisterArea[5 * 10]), - context_offset (FloatSave.RegisterArea[6 * 10]), - context_offset (FloatSave.RegisterArea[7 * 10]), - context_offset (FloatSave.ControlWord), - context_offset (FloatSave.StatusWord), - context_offset (FloatSave.TagWord), - context_offset (FloatSave.ErrorSelector), - context_offset (FloatSave.ErrorOffset), - context_offset (FloatSave.DataSelector), - context_offset (FloatSave.DataOffset), - context_offset (FloatSave.ErrorSelector) - /* XMM0-7 */ , - context_offset (ExtendedRegisters[10*16]), - context_offset (ExtendedRegisters[11*16]), - context_offset (ExtendedRegisters[12*16]), - context_offset (ExtendedRegisters[13*16]), - context_offset (ExtendedRegisters[14*16]), - context_offset (ExtendedRegisters[15*16]), - context_offset (ExtendedRegisters[16*16]), - context_offset (ExtendedRegisters[17*16]), - /* MXCSR */ - context_offset (ExtendedRegisters[24]) -}; - -#undef context_offset +static const int *mappings; /* This vector maps the target's idea of an exception (extracted from the DEBUG_EVENT structure) to GDB's idea. */ @@ -238,6 +202,15 @@ static const struct xlate_exception {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE}, {-1, -1}}; +/* Set the MAPPINGS static global to OFFSETS. + See the description of MAPPINGS for more details. */ + +void +windows_set_context_register_offsets (const int *offsets) +{ + mappings = offsets; +} + static void check (BOOL ok, const char *file, int line) { @@ -282,7 +255,7 @@ thread_rec (DWORD id, int get_context) /* Add a thread to the thread list. */ static thread_info * -win32_add_thread (ptid_t ptid, HANDLE h) +windows_add_thread (ptid_t ptid, HANDLE h) { thread_info *th; DWORD id; @@ -321,11 +294,11 @@ win32_add_thread (ptid_t ptid, HANDLE h) /* Clear out any old thread list and reintialize it to a pristine state. */ static void -win32_init_thread_list (void) +windows_init_thread_list (void) { thread_info *th = &thread_head; - DEBUG_EVENTS (("gdb: win32_init_thread_list\n")); + DEBUG_EVENTS (("gdb: windows_init_thread_list\n")); init_thread_list (); while (th->next != NULL) { @@ -338,7 +311,7 @@ win32_init_thread_list (void) /* Delete a thread from the list of threads */ static void -win32_delete_thread (ptid_t ptid) +windows_delete_thread (ptid_t ptid) { thread_info *th; DWORD id; @@ -365,7 +338,7 @@ win32_delete_thread (ptid_t ptid) } static void -do_win32_fetch_inferior_registers (struct regcache *regcache, int r) +do_windows_fetch_inferior_registers (struct regcache *regcache, int r) { char *context_offset = ((char *) ¤t_thread->context) + mappings[r]; struct gdbarch *gdbarch = get_regcache_arch (regcache); @@ -423,22 +396,23 @@ do_win32_fetch_inferior_registers (struct regcache *regcache, int r) else { for (r = 0; r < gdbarch_num_regs (gdbarch); r++) - do_win32_fetch_inferior_registers (regcache, r); + do_windows_fetch_inferior_registers (regcache, r); } } static void -win32_fetch_inferior_registers (struct regcache *regcache, int r) +windows_fetch_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int r) { current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE); /* Check if current_thread exists. Windows sometimes uses a non-existent thread id in its events */ if (current_thread) - do_win32_fetch_inferior_registers (regcache, r); + do_windows_fetch_inferior_registers (regcache, r); } static void -do_win32_store_inferior_registers (const struct regcache *regcache, int r) +do_windows_store_inferior_registers (const struct regcache *regcache, int r) { if (!current_thread) /* Windows sometimes uses a non-existent thread id in its events */; @@ -448,19 +422,20 @@ do_win32_store_inferior_registers (const struct regcache *regcache, int r) else { for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++) - do_win32_store_inferior_registers (regcache, r); + do_windows_store_inferior_registers (regcache, r); } } /* Store a new register value into the current thread context */ static void -win32_store_inferior_registers (struct regcache *regcache, int r) +windows_store_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int r) { current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE); /* Check if current_thread exists. Windows sometimes uses a non-existent thread id in its events */ if (current_thread) - do_win32_store_inferior_registers (regcache, r); + do_windows_store_inferior_registers (regcache, r); } static int psapi_loaded = 0; @@ -475,7 +450,7 @@ static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, is zero return the first loaded module (which is always the name of the executable). */ static int -get_module_name (DWORD base_address, char *dll_name_ret) +get_module_name (LPVOID base_address, char *dll_name_ret) { DWORD len; MODULEINFO mi; @@ -518,7 +493,7 @@ get_module_name (DWORD base_address, char *dll_name_ret) &mi, sizeof (mi))) error (_("Can't get module info")); - if (!base_address || (DWORD) (mi.lpBaseOfDll) == base_address) + if (!base_address || mi.lpBaseOfDll == base_address) { /* Try to find the name of the given module */ len = psapi_GetModuleFileNameExA (current_process_handle, @@ -554,7 +529,7 @@ struct safe_symbol_file_add_args /* Maintain a linked list of "so" information. */ struct lm_info { - DWORD load_addr; + LPVOID load_addr; }; static struct so_list solib_start, *solib_end; @@ -613,7 +588,7 @@ safe_symbol_file_add (char *name, int from_tty, } static struct so_list * -win32_make_so (const char *name, DWORD load_addr) +windows_make_so (const char *name, LPVOID load_addr) { struct so_list *so; char buf[MAX_PATH + 1]; @@ -678,7 +653,7 @@ win32_make_so (const char *name, DWORD load_addr) /* The symbols in a dll are offset by 0x1000, which is the the offset from 0 of the first byte in an image - because of the file header and the section alignment. */ - cygwin_load_start = load_addr + 0x1000; + cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000); cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text); bfd_close (abfd); @@ -696,7 +671,7 @@ get_image_name (HANDLE h, void *address, int unicode) char *address_ptr; int len = 0; char b[2]; - DWORD done; + SIZE_T done; /* Attempt to read the name of the dll that was detected. This is documented to work only when actively debugging @@ -740,7 +715,7 @@ handle_load_dll (void *dummy) dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0'; - if (!get_module_name ((DWORD) event->lpBaseOfDll, dll_buf)) + if (!get_module_name (event->lpBaseOfDll, dll_buf)) dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0'; dll_name = dll_buf; @@ -751,17 +726,17 @@ handle_load_dll (void *dummy) if (!dll_name) return 1; - solib_end->next = win32_make_so (dll_name, (DWORD) event->lpBaseOfDll); + solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll); solib_end = solib_end->next; - DEBUG_EVENTS (("gdb: Loading dll \"%s\" at 0x%lx.\n", solib_end->so_name, - (DWORD) solib_end->lm_info->load_addr)); + DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %p.\n", solib_end->so_name, + solib_end->lm_info->load_addr)); return 1; } static void -win32_free_so (struct so_list *so) +windows_free_so (struct so_list *so) { if (so->lm_info) xfree (so->lm_info); @@ -771,7 +746,7 @@ win32_free_so (struct so_list *so) static int handle_unload_dll (void *dummy) { - DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll; + LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll; struct so_list *so; for (so = &solib_start; so->next != NULL; so = so->next) @@ -783,19 +758,19 @@ handle_unload_dll (void *dummy) solib_end = so; DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name)); - win32_free_so (sodel); + windows_free_so (sodel); solib_add (NULL, 0, NULL, auto_solib_add); return 1; } - error (_("Error: dll starting at 0x%lx not found."), (DWORD) lpBaseOfDll); + error (_("Error: dll starting at %p not found."), lpBaseOfDll); return 0; } /* Clear list of loaded DLLs. */ static void -win32_clear_solib (void) +windows_clear_solib (void) { solib_start.next = NULL; solib_end = &solib_start; @@ -1000,8 +975,8 @@ info_w32_command (char *args, int from_tty) #define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \ - printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \ - (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress) + printf_unfiltered ("gdb: Target exception %s at %p\n", x, \ + current_event.u.Exception.ExceptionRecord.ExceptionAddress) static int handle_exception (struct target_waitstatus *ourstatus) @@ -1028,8 +1003,7 @@ handle_exception (struct target_waitstatus *ourstatus) and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up within the text segment of the DLL itself. */ char *fn; - bfd_vma addr = (bfd_vma) (uintptr_t) current_event.u.Exception. - ExceptionRecord.ExceptionAddress; + CORE_ADDR addr = (CORE_ADDR) (uintptr_t) current_event.u.Exception.ExceptionRecord.ExceptionAddress; if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end)) || (find_pc_partial_function (addr, &fn, NULL, NULL) && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0)) @@ -1113,9 +1087,9 @@ handle_exception (struct target_waitstatus *ourstatus) /* Treat unhandled first chance exceptions specially. */ if (current_event.u.Exception.dwFirstChance) return -1; - printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n", + printf_unfiltered ("gdb: unknown target exception 0x%08lx at %p\n", current_event.u.Exception.ExceptionRecord.ExceptionCode, - (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress); + current_event.u.Exception.ExceptionRecord.ExceptionAddress); ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; break; } @@ -1127,7 +1101,7 @@ handle_exception (struct target_waitstatus *ourstatus) /* Resume all artificially suspended threads if we are continuing execution */ static BOOL -win32_continue (DWORD continue_status, int id) +windows_continue (DWORD continue_status, int id) { int i; thread_info *th; @@ -1186,14 +1160,15 @@ fake_create_process (void) /* We can not debug anything in that case. */ } main_thread_id = current_event.dwThreadId; - current_thread = win32_add_thread (ptid_build (current_event.dwProcessId, 0, - current_event.dwThreadId), - current_event.u.CreateThread.hThread); + current_thread = windows_add_thread (ptid_build (current_event.dwProcessId, 0, + current_event.dwThreadId), + current_event.u.CreateThread.hThread); return main_thread_id; } static void -win32_resume (ptid_t ptid, int step, enum target_signal sig) +windows_resume (struct target_ops *ops, + ptid_t ptid, int step, enum target_signal sig) { thread_info *th; DWORD continue_status = DBG_CONTINUE; @@ -1242,7 +1217,7 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig) last_sig = TARGET_SIGNAL_0; - DEBUG_EXEC (("gdb: win32_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n", + DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n", ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig)); /* Get context for currently selected thread */ @@ -1252,8 +1227,9 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig) if (step) { /* Single step by setting t bit */ - win32_fetch_inferior_registers (get_current_regcache (), - gdbarch_ps_regnum (current_gdbarch)); + windows_fetch_inferior_registers (ops, + get_current_regcache (), + gdbarch_ps_regnum (current_gdbarch)); th->context.EFlags |= FLAG_TRACE_BIT; } @@ -1277,16 +1253,17 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig) Otherwise complain. */ if (resume_all) - win32_continue (continue_status, -1); + windows_continue (continue_status, -1); else - win32_continue (continue_status, ptid_get_tid (ptid)); + windows_continue (continue_status, ptid_get_tid (ptid)); } /* Get the next event from the child. Return 1 if the event requires handling by WFI (or whatever). */ static int -get_win32_debug_event (int pid, struct target_waitstatus *ourstatus) +get_windows_debug_event (struct target_ops *ops, + int pid, struct target_waitstatus *ourstatus) { BOOL debug_event; DWORD continue_status, event_code; @@ -1316,20 +1293,22 @@ get_win32_debug_event (int pid, struct target_waitstatus *ourstatus) "CREATE_THREAD_DEBUG_EVENT")); if (saw_create != 1) { - if (!saw_create && attach_flag) + struct inferior *inf; + inf = find_inferior_pid (current_event.dwProcessId); + if (!saw_create && inf->attach_flag) { /* Kludge around a Windows bug where first event is a create thread event. Caused when attached process does not have a main thread. */ retval = fake_create_process (); - if (retval) - saw_create++; + if (retval) + saw_create++; } break; } /* Record the existence of this thread */ retval = current_event.dwThreadId; - th = win32_add_thread (ptid_build (current_event.dwProcessId, 0, + th = windows_add_thread (ptid_build (current_event.dwProcessId, 0, current_event.dwThreadId), current_event.u.CreateThread.hThread); break; @@ -1341,7 +1320,7 @@ get_win32_debug_event (int pid, struct target_waitstatus *ourstatus) "EXIT_THREAD_DEBUG_EVENT")); if (current_event.dwThreadId != main_thread_id) { - win32_delete_thread (ptid_build (current_event.dwProcessId, 0, + windows_delete_thread (ptid_build (current_event.dwProcessId, 0, current_event.dwThreadId)); th = &dummy_thread_info; } @@ -1358,11 +1337,11 @@ get_win32_debug_event (int pid, struct target_waitstatus *ourstatus) current_process_handle = current_event.u.CreateProcessInfo.hProcess; if (main_thread_id) - win32_delete_thread (ptid_build (current_event.dwProcessId, 0, + windows_delete_thread (ptid_build (current_event.dwProcessId, 0, main_thread_id)); main_thread_id = current_event.dwThreadId; /* Add the main thread */ - th = win32_add_thread (ptid_build (current_event.dwProcessId, 0, + th = windows_add_thread (ptid_build (current_event.dwProcessId, 0, current_event.dwThreadId), current_event.u.CreateProcessInfo.hThread); retval = current_event.dwThreadId; @@ -1453,9 +1432,9 @@ get_win32_debug_event (int pid, struct target_waitstatus *ourstatus) if (!retval || saw_create != 1) { if (continue_status == -1) - win32_resume (minus_one_ptid, 0, 1); + windows_resume (ops, minus_one_ptid, 0, 1); else - CHECK (win32_continue (continue_status, -1)); + CHECK (windows_continue (continue_status, -1)); } else { @@ -1470,7 +1449,8 @@ out: /* Wait for interesting events to occur in the target process. */ static ptid_t -win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +windows_wait (struct target_ops *ops, + ptid_t ptid, struct target_waitstatus *ourstatus) { int pid = -1; @@ -1500,7 +1480,7 @@ win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus) to find a better solution to that problem. But in the meantime, the current approach already greatly mitigate this issue. */ SetConsoleCtrlHandler (NULL, TRUE); - retval = get_win32_debug_event (pid, ourstatus); + retval = get_windows_debug_event (ops, pid, ourstatus); SetConsoleCtrlHandler (NULL, FALSE); if (retval) @@ -1513,13 +1493,13 @@ win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus) detach = deprecated_ui_loop_hook (0); if (detach) - win32_kill_inferior (); + windows_kill_inferior (); } } } static void -do_initial_win32_stuff (DWORD pid) +do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) { extern int stop_after_trap; int i; @@ -1539,13 +1519,20 @@ do_initial_win32_stuff (DWORD pid) #endif current_event.dwProcessId = pid; memset (¤t_event, 0, sizeof (current_event)); - push_target (&win32_ops); + push_target (ops); disable_breakpoints_in_shlibs (); - win32_clear_solib (); + windows_clear_solib (); clear_proceed_status (); init_wait_for_inferior (); inf = add_inferior (pid); + inf->attach_flag = attaching; + + /* Make the new process the current inferior, so terminal handling + can rely on it. When attaching, we don't know about any thread + id here, but that's OK --- nothing should be referencing the + current thread until we report an event out of windows_wait. */ + inferior_ptid = pid_to_ptid (pid); terminal_init_inferior_with_pgrp (pid); target_terminal_inferior (); @@ -1572,8 +1559,8 @@ do_initial_win32_stuff (DWORD pid) If loading these functions succeeds use them to actually detach from the inferior process, otherwise behave as usual, pretending that detach has worked. */ -static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL); -static BOOL WINAPI (*DebugActiveProcessStop)(DWORD); +static BOOL WINAPI (*kernel32_DebugSetProcessKillOnExit)(BOOL); +static BOOL WINAPI (*kernel32_DebugActiveProcessStop)(DWORD); static int has_detach_ability (void) @@ -1584,13 +1571,14 @@ has_detach_ability (void) kernel32 = LoadLibrary ("kernel32.dll"); if (kernel32) { - if (!DebugSetProcessKillOnExit) - DebugSetProcessKillOnExit = GetProcAddress (kernel32, - "DebugSetProcessKillOnExit"); - if (!DebugActiveProcessStop) - DebugActiveProcessStop = GetProcAddress (kernel32, - "DebugActiveProcessStop"); - if (DebugSetProcessKillOnExit && DebugActiveProcessStop) + if (!kernel32_DebugSetProcessKillOnExit) + kernel32_DebugSetProcessKillOnExit = + (void *) GetProcAddress (kernel32, "DebugSetProcessKillOnExit"); + if (!kernel32_DebugActiveProcessStop) + kernel32_DebugActiveProcessStop = + (void *) GetProcAddress (kernel32, "DebugActiveProcessStop"); + if (kernel32_DebugSetProcessKillOnExit + && kernel32_DebugActiveProcessStop) return 1; } return 0; @@ -1625,13 +1613,14 @@ set_process_privilege (const char *privilege, BOOL enable) if (!(advapi32 = LoadLibrary ("advapi32.dll"))) goto out; if (!OpenProcessToken) - OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken"); + OpenProcessToken = + (void *) GetProcAddress (advapi32, "OpenProcessToken"); if (!LookupPrivilegeValue) - LookupPrivilegeValue = GetProcAddress (advapi32, - "LookupPrivilegeValueA"); + LookupPrivilegeValue = + (void *) GetProcAddress (advapi32, "LookupPrivilegeValueA"); if (!AdjustTokenPrivileges) - AdjustTokenPrivileges = GetProcAddress (advapi32, - "AdjustTokenPrivileges"); + AdjustTokenPrivileges = + (void *) GetProcAddress (advapi32, "AdjustTokenPrivileges"); if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges) { advapi32 = NULL; @@ -1657,7 +1646,7 @@ set_process_privilege (const char *privilege, BOOL enable) #if 0 /* Disabled, otherwise every `attach' in an unprivileged user session would raise the "Failed to get SE_DEBUG_NAME privilege" warning in - win32_attach(). */ + windows_attach(). */ /* AdjustTokenPrivileges returns TRUE even if the privilege could not be enabled. GetLastError () returns an correct error code, though. */ if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED) @@ -1675,7 +1664,7 @@ out: /* Attach to process PID, then initialize for debugging it. */ static void -win32_attach (char *args, int from_tty) +windows_attach (struct target_ops *ops, char *args, int from_tty) { BOOL ok; DWORD pid; @@ -1691,7 +1680,7 @@ win32_attach (char *args, int from_tty) pid = strtoul (args, 0, 0); /* Windows pid */ - win32_init_thread_list (); + windows_init_thread_list (); ok = DebugActiveProcess (pid); saw_create = 0; @@ -1710,9 +1699,7 @@ win32_attach (char *args, int from_tty) error (_("Can't attach to process.")); if (has_detach_ability ()) - DebugSetProcessKillOnExit (FALSE); - - attach_flag = 1; + kernel32_DebugSetProcessKillOnExit (FALSE); if (from_tty) { @@ -1728,27 +1715,27 @@ win32_attach (char *args, int from_tty) gdb_flush (gdb_stdout); } - do_initial_win32_stuff (pid); + do_initial_windows_stuff (ops, pid, 1); target_terminal_ours (); } static void -win32_detach (char *args, int from_tty) +windows_detach (struct target_ops *ops, char *args, int from_tty) { int detached = 1; if (has_detach_ability ()) { ptid_t ptid = {-1}; - win32_resume (ptid, 0, TARGET_SIGNAL_0); + windows_resume (ops, ptid, 0, TARGET_SIGNAL_0); - if (!DebugActiveProcessStop (current_event.dwProcessId)) + if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId)) { error (_("Can't detach process %lu (error %lu)"), current_event.dwProcessId, GetLastError ()); detached = 0; } - DebugSetProcessKillOnExit (FALSE); + kernel32_DebugSetProcessKillOnExit (FALSE); } if (detached && from_tty) { @@ -1763,11 +1750,11 @@ win32_detach (char *args, int from_tty) inferior_ptid = null_ptid; detach_inferior (current_event.dwProcessId); - unpush_target (&win32_ops); + unpush_target (ops); } static char * -win32_pid_to_exec_file (int pid) +windows_pid_to_exec_file (int pid) { static char path[MAX_PATH + 1]; @@ -1795,26 +1782,29 @@ win32_pid_to_exec_file (int pid) /* Print status information about what we're accessing. */ static void -win32_files_info (struct target_ops *ignore) +windows_files_info (struct target_ops *ignore) { + struct inferior *inf = current_inferior (); + printf_unfiltered ("\tUsing the running image of %s %s.\n", - attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid)); + inf->attach_flag ? "attached" : "child", + target_pid_to_str (inferior_ptid)); } static void -win32_open (char *arg, int from_tty) +windows_open (char *arg, int from_tty) { 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 windows child process and sets inferior_ptid to its pid. EXEC_FILE is the file to run. ALLARGS is a string containing the arguments to the program. ENV is the environment vector to pass. Errors reported with error(). */ static void -win32_create_inferior (char *exec_file, char *allargs, char **in_env, - int from_tty) +windows_create_inferior (struct target_ops *ops, char *exec_file, + char *allargs, char **in_env, int from_tty) { STARTUPINFO si; PROCESS_INFORMATION pi; @@ -1867,8 +1857,6 @@ win32_create_inferior (char *exec_file, char *allargs, char **in_env, if (new_console) flags |= CREATE_NEW_CONSOLE; - attach_flag = 0; - args = alloca (strlen (toexec) + strlen (allargs) + 2); strcpy (args, toexec); strcat (args, " "); @@ -1900,7 +1888,7 @@ win32_create_inferior (char *exec_file, char *allargs, char **in_env, } #endif - win32_init_thread_list (); + windows_init_thread_list (); ret = CreateProcess (0, args, /* command line */ NULL, /* Security */ @@ -1937,22 +1925,22 @@ win32_create_inferior (char *exec_file, char *allargs, char **in_env, else saw_create = 0; - do_initial_win32_stuff (pi.dwProcessId); + do_initial_windows_stuff (ops, pi.dwProcessId, 0); - /* win32_continue (DBG_CONTINUE, -1); */ + /* windows_continue (DBG_CONTINUE, -1); */ } static void -win32_mourn_inferior (void) +windows_mourn_inferior (struct target_ops *ops) { - (void) win32_continue (DBG_CONTINUE, -1); + (void) windows_continue (DBG_CONTINUE, -1); i386_cleanup_dregs(); if (open_process_used) { CHECK (CloseHandle (current_process_handle)); open_process_used = 0; } - unpush_target (&win32_ops); + unpush_target (ops); generic_mourn_inferior (); } @@ -1960,7 +1948,7 @@ win32_mourn_inferior (void) ^C on the controlling terminal. */ static void -win32_stop (ptid_t ptid) +windows_stop (ptid_t ptid) { DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n")); CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId)); @@ -1968,11 +1956,11 @@ win32_stop (ptid_t ptid) } static int -win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len, +windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len, int write, struct mem_attrib *mem, struct target_ops *target) { - DWORD done = 0; + SIZE_T done = 0; if (write) { DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n", @@ -1997,13 +1985,13 @@ win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len, } static void -win32_kill_inferior (void) +windows_kill_inferior (void) { CHECK (TerminateProcess (current_process_handle, 0)); for (;;) { - if (!win32_continue (DBG_CONTINUE, -1)) + if (!windows_continue (DBG_CONTINUE, -1)) break; if (!WaitForDebugEvent (¤t_event, INFINITE)) break; @@ -2011,31 +1999,31 @@ win32_kill_inferior (void) break; } - target_mourn_inferior (); /* or just win32_mourn_inferior? */ + target_mourn_inferior (); /* or just windows_mourn_inferior? */ } static void -win32_prepare_to_store (struct regcache *regcache) +windows_prepare_to_store (struct regcache *regcache) { /* Do nothing, since we can store individual regs */ } static int -win32_can_run (void) +windows_can_run (void) { return 1; } static void -win32_close (int x) +windows_close (int x) { - DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n", + DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n", PIDGET (inferior_ptid))); } /* Convert pid to printable format. */ static char * -win32_pid_to_str (ptid_t ptid) +windows_pid_to_str (struct target_ops *ops, ptid_t ptid) { static char buf[80]; @@ -2050,7 +2038,7 @@ win32_pid_to_str (ptid_t ptid) } static LONGEST -win32_xfer_shared_libraries (struct target_ops *ops, +windows_xfer_shared_libraries (struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len) @@ -2066,7 +2054,8 @@ win32_xfer_shared_libraries (struct target_ops *ops, obstack_init (&obstack); obstack_grow_str (&obstack, "\n"); for (so = solib_start.next; so; so = so->next) - win32_xfer_shared_library (so->so_name, so->lm_info->load_addr, &obstack); + windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr, + &obstack); obstack_grow_str0 (&obstack, "\n"); buf = obstack_finish (&obstack); @@ -2083,7 +2072,7 @@ win32_xfer_shared_libraries (struct target_ops *ops, } static LONGEST -win32_xfer_partial (struct target_ops *ops, enum target_object object, +windows_xfer_partial (struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, LONGEST len) { @@ -2099,7 +2088,7 @@ win32_xfer_partial (struct target_ops *ops, enum target_object object, return -1; case TARGET_OBJECT_LIBRARIES: - return win32_xfer_shared_libraries (ops, object, annex, readbuf, + return windows_xfer_shared_libraries (ops, object, annex, readbuf, writebuf, offset, len); default: @@ -2111,61 +2100,63 @@ win32_xfer_partial (struct target_ops *ops, enum target_object object, } static void -init_win32_ops (void) +init_windows_ops (void) { - win32_ops.to_shortname = "child"; - win32_ops.to_longname = "Win32 child process"; - win32_ops.to_doc = "Win32 child process (started by the \"run\" command)."; - win32_ops.to_open = win32_open; - win32_ops.to_close = win32_close; - win32_ops.to_attach = win32_attach; - win32_ops.to_attach_no_wait = 1; - win32_ops.to_detach = win32_detach; - win32_ops.to_resume = win32_resume; - win32_ops.to_wait = win32_wait; - win32_ops.to_fetch_registers = win32_fetch_inferior_registers; - win32_ops.to_store_registers = win32_store_inferior_registers; - win32_ops.to_prepare_to_store = win32_prepare_to_store; - win32_ops.deprecated_xfer_memory = win32_xfer_memory; - win32_ops.to_xfer_partial = win32_xfer_partial; - win32_ops.to_files_info = win32_files_info; - win32_ops.to_insert_breakpoint = memory_insert_breakpoint; - win32_ops.to_remove_breakpoint = memory_remove_breakpoint; - win32_ops.to_terminal_init = terminal_init_inferior; - win32_ops.to_terminal_inferior = terminal_inferior; - win32_ops.to_terminal_ours_for_output = terminal_ours_for_output; - win32_ops.to_terminal_ours = terminal_ours; - win32_ops.to_terminal_save_ours = terminal_save_ours; - win32_ops.to_terminal_info = child_terminal_info; - win32_ops.to_kill = win32_kill_inferior; - win32_ops.to_create_inferior = win32_create_inferior; - win32_ops.to_mourn_inferior = win32_mourn_inferior; - win32_ops.to_can_run = win32_can_run; - win32_ops.to_thread_alive = win32_win32_thread_alive; - win32_ops.to_pid_to_str = win32_pid_to_str; - win32_ops.to_stop = win32_stop; - win32_ops.to_stratum = process_stratum; - win32_ops.to_has_all_memory = 1; - win32_ops.to_has_memory = 1; - win32_ops.to_has_stack = 1; - win32_ops.to_has_registers = 1; - win32_ops.to_has_execution = 1; - win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file; - win32_ops.to_magic = OPS_MAGIC; + windows_ops.to_shortname = "child"; + windows_ops.to_longname = "Win32 child process"; + windows_ops.to_doc = "Win32 child process (started by the \"run\" command)."; + windows_ops.to_open = windows_open; + windows_ops.to_close = windows_close; + windows_ops.to_attach = windows_attach; + windows_ops.to_attach_no_wait = 1; + windows_ops.to_detach = windows_detach; + windows_ops.to_resume = windows_resume; + windows_ops.to_wait = windows_wait; + windows_ops.to_fetch_registers = windows_fetch_inferior_registers; + windows_ops.to_store_registers = windows_store_inferior_registers; + windows_ops.to_prepare_to_store = windows_prepare_to_store; + windows_ops.deprecated_xfer_memory = windows_xfer_memory; + windows_ops.to_xfer_partial = windows_xfer_partial; + windows_ops.to_files_info = windows_files_info; + windows_ops.to_insert_breakpoint = memory_insert_breakpoint; + windows_ops.to_remove_breakpoint = memory_remove_breakpoint; + windows_ops.to_terminal_init = terminal_init_inferior; + windows_ops.to_terminal_inferior = terminal_inferior; + windows_ops.to_terminal_ours_for_output = terminal_ours_for_output; + windows_ops.to_terminal_ours = terminal_ours; + windows_ops.to_terminal_save_ours = terminal_save_ours; + windows_ops.to_terminal_info = child_terminal_info; + windows_ops.to_kill = windows_kill_inferior; + windows_ops.to_create_inferior = windows_create_inferior; + windows_ops.to_mourn_inferior = windows_mourn_inferior; + windows_ops.to_can_run = windows_can_run; + windows_ops.to_thread_alive = windows_thread_alive; + windows_ops.to_pid_to_str = windows_pid_to_str; + windows_ops.to_stop = windows_stop; + windows_ops.to_stratum = process_stratum; + windows_ops.to_has_all_memory = 1; + windows_ops.to_has_memory = 1; + windows_ops.to_has_stack = 1; + windows_ops.to_has_registers = 1; + windows_ops.to_has_execution = 1; + windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file; + i386_use_watchpoints (&windows_ops); + + windows_ops.to_magic = OPS_MAGIC; } static void -set_win32_aliases (char *argv0) +set_windows_aliases (char *argv0) { add_info_alias ("dll", "sharedlibrary", 1); } void -_initialize_win32_nat (void) +_initialize_windows_nat (void) { struct cmd_list_element *c; - init_win32_ops (); + init_windows_ops (); c = add_com ("dll-symbols", class_files, dll_symbol_command, _("Load dll library symbols from FILE.")); @@ -2239,15 +2230,15 @@ Show whether to display kernel exceptions in child process."), NULL, add_cmd ("selector", class_info, display_selectors, _("Display selectors infos."), &info_w32_cmdlist); - add_target (&win32_ops); - deprecated_init_ui_hook = set_win32_aliases; + add_target (&windows_ops); + deprecated_init_ui_hook = set_windows_aliases; } /* Hardware watchpoint support, adapted from go32-nat.c code. */ /* 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 - actually set up when win32_continue is called. */ + actually set up when windows_continue is called. */ void cygwin_set_dr (int i, CORE_ADDR addr) { @@ -2261,7 +2252,7 @@ cygwin_set_dr (int i, CORE_ADDR addr) /* Pass the value VAL to the inferior in the DR7 debug control register. Here we just store the address in D_REGS, the watchpoint - will be actually set up in win32_wait. */ + will be actually set up in windows_wait. */ void cygwin_set_dr7 (unsigned val) { @@ -2283,7 +2274,7 @@ cygwin_get_dr6 (void) by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0 it means that the thread has died. Otherwise it is assumed to be alive. */ static int -win32_win32_thread_alive (ptid_t ptid) +windows_thread_alive (struct target_ops *ops, ptid_t ptid) { int tid;