-/* 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, 2009 Free Software Foundation, Inc.
+ 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Cygnus Solutions, A Red Hat Company.
#include <stdlib.h>
#include <windows.h>
#include <imagehlp.h>
+#include <psapi.h>
#ifdef __CYGWIN__
#include <sys/cygwin.h>
#endif
#include "i386-tdep.h"
#include "i387-tdep.h"
-#include "win32-tdep.h"
-#include "win32-nat.h"
-
-static struct target_ops win32_ops;
+#include "windows-tdep.h"
+#include "windows-nat.h"
+#include "i386-nat.h"
+
+#define AdjustTokenPrivileges dyn_AdjustTokenPrivileges
+#define DebugActiveProcessStop dyn_DebugActiveProcessStop
+#define DebugBreakProcess dyn_DebugBreakProcess
+#define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit
+#define EnumProcessModules dyn_EnumProcessModules
+#define GetModuleFileNameExA dyn_GetModuleFileNameExA
+#define GetModuleInformation dyn_GetModuleInformation
+#define LookupPrivilegeValueA dyn_LookupPrivilegeValueA
+#define OpenProcessToken dyn_OpenProcessToken
+
+static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
+ DWORD, PTOKEN_PRIVILEGES, PDWORD);
+static BOOL WINAPI (*DebugActiveProcessStop) (DWORD);
+static BOOL WINAPI (*DebugBreakProcess) (HANDLE);
+static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL);
+static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD,
+ LPDWORD);
+static DWORD WINAPI (*GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
+ DWORD);
+static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
+ DWORD);
+static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
+static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
+
+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. */
CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
};
#endif
-#include <psapi.h>
#ifndef CONTEXT_EXTENDED_REGISTERS
/* This macro is only defined on ia32. It only makes sense on this target,
#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
| CONTEXT_EXTENDED_REGISTERS
-static unsigned dr[8];
+static uintptr_t dr[8];
static int debug_registers_changed;
static int debug_registers_used;
#define DR6_CLEAR_VALUE 0xffff0ff0
#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 (struct target_ops *);
+
+static void cygwin_set_dr (int i, CORE_ADDR addr);
+static void cygwin_set_dr7 (unsigned long val);
+static unsigned long cygwin_get_dr6 (void);
static enum target_signal last_sig = TARGET_SIGNAL_0;
/* Set if a signal was received from the debugged process */
static int useshell = 0; /* use shell for subprocesses */
/* This vector maps GDB's idea of a register's number into an offset
- in the win32 exception context vector.
+ 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
- win32_set_context_register_offsets.
+ 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,
See the description of MAPPINGS for more details. */
void
-win32_set_context_register_offsets (const int *offsets)
+windows_set_context_register_offsets (const int *offsets)
{
mappings = offsets;
}
/* 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;
/* 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)
{
/* 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;
}
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);
thread_info *th = current_thread;
th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
GetThreadContext (th->h, &th->context);
- /* Copy dr values from that thread.
+ /* Copy dr values from that thread.
But only if there were not modified since last stop. PR gdb/2388 */
if (!debug_registers_changed)
{
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 */;
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;
-static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD,
- LPDWORD);
-static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
- DWORD);
-static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
- DWORD);
-
/* Get the name of a given module at at given base address. If base_address
is zero return the first loaded module (which is always the name of the
executable). */
char *pathbuf = dll_name_ret; /* Just copy directly to passed-in arg */
#endif
- /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
- the needed functions. */
- if (psapi_loaded <= 0)
- goto failed;
-
cbNeeded = 0;
/* Find size of buffer needed to handle list of modules loaded in inferior */
- if (!psapi_EnumProcessModules (current_process_handle, DllHandle,
- sizeof (HMODULE), &cbNeeded) || !cbNeeded)
+ if (!EnumProcessModules (current_process_handle, DllHandle,
+ sizeof (HMODULE), &cbNeeded) || !cbNeeded)
goto failed;
/* Allocate correct amount of space for module list */
goto failed;
/* Get the list of modules */
- if (!psapi_EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
+ if (!EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
&cbNeeded))
goto failed;
for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
{
/* Get information on this module */
- if (!psapi_GetModuleInformation (current_process_handle, DllHandle[i],
- &mi, sizeof (mi)))
+ if (!GetModuleInformation (current_process_handle, DllHandle[i],
+ &mi, sizeof (mi)))
error (_("Can't get module info"));
if (!base_address || mi.lpBaseOfDll == base_address)
{
/* Try to find the name of the given module */
- len = psapi_GetModuleFileNameExA (current_process_handle,
- DllHandle[i], pathbuf, MAX_PATH);
+ len = GetModuleFileNameExA (current_process_handle,
+ DllHandle[i], pathbuf, MAX_PATH);
if (len == 0)
error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
#ifdef __CYGWIN__
safe_symbol_file_add_stub (void *argv)
{
#define p ((struct safe_symbol_file_add_args *) argv)
- p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
+ const int add_flags = ((p->from_tty ? SYMFILE_VERBOSE : 0)
+ | (p->mainline ? SYMFILE_MAINLINE : 0));
+ p->ret = symbol_file_add (p->name, add_flags, p->addrs, p->flags);
return !!p->ret;
#undef p
}
}
static struct so_list *
-win32_make_so (const char *name, LPVOID load_addr)
+windows_make_so (const char *name, LPVOID load_addr)
{
struct so_list *so;
char buf[MAX_PATH + 1];
/* 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);
if (!dll_name)
return 1;
- solib_end->next = win32_make_so (dll_name, 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,
- solib_end->lm_info->load_addr));
+ DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
+ host_address_to_string (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);
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 %s not found."),
+ host_address_to_string (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;
#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
- printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
- current_event.u.Exception.ExceptionRecord.ExceptionAddress)
+ printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
+ host_address_to_string (\
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress))
static int
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))
/* 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",
- current_event.u.Exception.ExceptionRecord.ExceptionCode,
- current_event.u.Exception.ExceptionRecord.ExceptionAddress);
+ printf_unfiltered ("gdb: unknown target exception 0x%08lx at %s\n",
+ current_event.u.Exception.ExceptionRecord.ExceptionCode,
+ host_address_to_string (
+ current_event.u.Exception.ExceptionRecord.ExceptionAddress));
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
}
/* 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;
/* 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;
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 */
if (step)
{
/* Single step by setting t bit */
- win32_fetch_inferior_registers (get_current_regcache (),
- gdbarch_ps_regnum (current_gdbarch));
+ struct regcache *regcache = get_current_regcache ();
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ windows_fetch_inferior_registers (ops, regcache,
+ gdbarch_ps_regnum (gdbarch));
th->context.EFlags |= FLAG_TRACE_BIT;
}
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));
+}
+
+/* Ctrl-C handler used when the inferior is not run in the same console. The
+ handler is in charge of interrupting the inferior using DebugBreakProcess.
+ Note that this function is not available prior to Windows XP. In this case
+ we emit a warning. */
+BOOL WINAPI
+ctrl_c_handler (DWORD event_type)
+{
+ const int attach_flag = current_inferior ()->attach_flag;
+
+ /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */
+ if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
+ return FALSE;
+
+ /* If the inferior and the debugger share the same console, do nothing as
+ the inferior has also received the Ctrl-C event. */
+ if (!new_console && !attach_flag)
+ return TRUE;
+
+ if (!DebugBreakProcess (current_process_handle))
+ warning (_("\
+Could not interrupt program. Press Ctrl-c in the program console."));
+
+ /* Return true to tell that Ctrl-C has been handled. */
+ return TRUE;
}
/* 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
-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;
}
/* 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;
"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;
}
current_process_handle = current_event.u.CreateProcessInfo.hProcess;
if (main_thread_id)
- win32_delete_thread (ptid_build (current_event.dwProcessId, 0,
- main_thread_id));
+ 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,
- current_event.dwThreadId),
- current_event.u.CreateProcessInfo.hThread);
+ th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
+ current_event.dwThreadId),
+ current_event.u.CreateProcessInfo.hThread);
retval = current_event.dwThreadId;
break;
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
{
/* 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 options)
{
int pid = -1;
while (1)
{
int retval;
-
- /* Ignore CTRL+C signals while waiting for a debug event.
- FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
- the inferior is running, both the inferior and GDB receive the
- associated signal. If the inferior receives the signal first
- and the delay until GDB receives that signal is sufficiently long,
- GDB can sometimes receive the SIGINT after we have unblocked
- the CTRL+C handler. This would lead to the debugger to stop
- prematurely while handling the new-thread event that comes
- with the handling of the SIGINT inside the inferior, and then
- stop again immediately when the user tries to resume the execution
- in the inferior. This is a classic race, and it would be nice
- 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);
- SetConsoleCtrlHandler (NULL, FALSE);
+
+ /* If the user presses Ctrl-c while the debugger is waiting
+ for an event, he expects the debugger to interrupt his program
+ and to get the prompt back. There are two possible situations:
+
+ - The debugger and the program do not share the console, in
+ which case the Ctrl-c event only reached the debugger.
+ In that case, the ctrl_c handler will take care of interrupting
+ the inferior. Note that this case is working starting with
+ Windows XP. For Windows 2000, Ctrl-C should be pressed in the
+ inferior console.
+
+ - The debugger and the program share the same console, in which
+ case both debugger and inferior will receive the Ctrl-c event.
+ In that case the ctrl_c handler will ignore the event, as the
+ Ctrl-c event generated inside the inferior will trigger the
+ expected debug event.
+
+ FIXME: brobecker/2008-05-20: If the inferior receives the
+ signal first and the delay until GDB receives that signal
+ is sufficiently long, GDB can sometimes receive the SIGINT
+ after we have unblocked the CTRL+C handler. This would
+ lead to the debugger stopping prematurely while handling
+ the new-thread event that comes with the handling of the SIGINT
+ inside the inferior, and then stop again immediately when
+ the user tries to resume the execution in the inferior.
+ This is a classic race that we should try to fix one day. */
+ SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
+ retval = get_windows_debug_event (ops, pid, ourstatus);
+ SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
if (retval)
return ptid_build (current_event.dwProcessId, 0, retval);
detach = deprecated_ui_loop_hook (0);
if (detach)
- win32_kill_inferior ();
+ windows_kill_inferior (ops);
}
}
}
static void
-do_initial_win32_stuff (struct target_ops *ops, DWORD pid, int attaching)
+do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
{
extern int stop_after_trap;
int i;
memset (¤t_event, 0, sizeof (current_event));
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 = current_inferior ();
+ inferior_appeared (inf, 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 win32_wait. */
+ current thread until we report an event out of windows_wait. */
inferior_ptid = pid_to_ptid (pid);
terminal_init_inferior_with_pgrp (pid);
return;
}
-/* Since Windows XP, detaching from a process is supported by Windows.
- The following code tries loading the appropriate functions dynamically.
- 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 (*kernel32_DebugSetProcessKillOnExit)(BOOL);
-static BOOL WINAPI (*kernel32_DebugActiveProcessStop)(DWORD);
-
-static int
-has_detach_ability (void)
-{
- static HMODULE kernel32 = NULL;
-
- if (!kernel32)
- kernel32 = LoadLibrary ("kernel32.dll");
- if (kernel32)
- {
- 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;
-}
-
/* Try to set or remove a user privilege to the current process. Return -1
if that fails, the previous setting of that privilege otherwise.
static int
set_process_privilege (const char *privilege, BOOL enable)
{
- static HMODULE advapi32 = NULL;
- static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
- static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
- static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
- DWORD, PTOKEN_PRIVILEGES, PDWORD);
-
HANDLE token_hdl = NULL;
LUID restore_priv;
TOKEN_PRIVILEGES new_priv, orig_priv;
int ret = -1;
DWORD size;
- if (GetVersion () >= 0x80000000) /* No security availbale on 9x/Me */
- return 0;
-
- if (!advapi32)
- {
- if (!(advapi32 = LoadLibrary ("advapi32.dll")))
- goto out;
- if (!OpenProcessToken)
- OpenProcessToken =
- (void *) GetProcAddress (advapi32, "OpenProcessToken");
- if (!LookupPrivilegeValue)
- LookupPrivilegeValue =
- (void *) GetProcAddress (advapi32, "LookupPrivilegeValueA");
- if (!AdjustTokenPrivileges)
- AdjustTokenPrivileges =
- (void *) GetProcAddress (advapi32, "AdjustTokenPrivileges");
- if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
- {
- advapi32 = NULL;
- goto out;
- }
- }
-
if (!OpenProcessToken (GetCurrentProcess (),
TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
&token_hdl))
goto out;
- if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
+ if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
goto out;
new_priv.PrivilegeCount = 1;
#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)
/* Attach to process PID, then initialize for debugging it. */
static void
-win32_attach (struct target_ops *ops, char *args, int from_tty)
+windows_attach (struct target_ops *ops, char *args, int from_tty)
{
BOOL ok;
DWORD pid;
pid = strtoul (args, 0, 0); /* Windows pid */
- win32_init_thread_list ();
+ windows_init_thread_list ();
ok = DebugActiveProcess (pid);
saw_create = 0;
if (!ok)
error (_("Can't attach to process."));
- if (has_detach_ability ())
- kernel32_DebugSetProcessKillOnExit (FALSE);
+ DebugSetProcessKillOnExit (FALSE);
if (from_tty)
{
gdb_flush (gdb_stdout);
}
- do_initial_win32_stuff (ops, pid, 1);
+ do_initial_windows_stuff (ops, pid, 1);
target_terminal_ours ();
}
static void
-win32_detach (struct target_ops *ops, 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);
+ ptid_t ptid = {-1};
+ windows_resume (ops, ptid, 0, TARGET_SIGNAL_0);
- if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId))
- {
- error (_("Can't detach process %lu (error %lu)"),
- current_event.dwProcessId, GetLastError ());
- detached = 0;
- }
- kernel32_DebugSetProcessKillOnExit (FALSE);
+ if (!DebugActiveProcessStop (current_event.dwProcessId))
+ {
+ error (_("Can't detach process %lu (error %lu)"),
+ current_event.dwProcessId, GetLastError ());
+ detached = 0;
}
+ DebugSetProcessKillOnExit (FALSE);
+
if (detached && from_tty)
{
char *exec_file = get_exec_file (0);
}
static char *
-win32_pid_to_exec_file (int pid)
+windows_pid_to_exec_file (int pid)
{
static char path[MAX_PATH + 1];
/* 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 ();
}
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 (struct target_ops *ops, char *exec_file,
+windows_create_inferior (struct target_ops *ops, char *exec_file,
char *allargs, char **in_env, int from_tty)
{
STARTUPINFO si;
char *toexec;
char shell[MAX_PATH + 1]; /* Path to shell */
const char *sh;
+#ifdef __CYGWIN__
int tty;
int ostdin, ostdout, ostderr;
+#else
+ HANDLE tty;
+#endif
const char *inferior_io_terminal = get_inferior_io_terminal ();
if (!exec_file)
dup2 (tty, 2);
}
}
+#else
+ if (!inferior_io_terminal)
+ tty = INVALID_HANDLE_VALUE;
+ else
+ {
+ SECURITY_ATTRIBUTES sa;
+ sa.nLength = sizeof(sa);
+ sa.lpSecurityDescriptor = 0;
+ sa.bInheritHandle = TRUE;
+ tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
+ 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+ if (tty == INVALID_HANDLE_VALUE)
+ warning (_("Warning: Failed to open TTY %s, error %#x."),
+ inferior_io_terminal, (unsigned) GetLastError ());
+ else
+ {
+ si.hStdInput = tty;
+ si.hStdOutput = tty;
+ si.hStdError = tty;
+ si.dwFlags |= STARTF_USESTDHANDLES;
+ }
+ }
#endif
- win32_init_thread_list ();
+ windows_init_thread_list ();
ret = CreateProcess (0,
args, /* command line */
NULL, /* Security */
close (ostdout);
close (ostderr);
}
+#else
+ if (tty != INVALID_HANDLE_VALUE)
+ CloseHandle (tty);
#endif
if (!ret)
else
saw_create = 0;
- do_initial_win32_stuff (ops, pi.dwProcessId, 0);
+ do_initial_windows_stuff (ops, pi.dwProcessId, 0);
- /* win32_continue (DBG_CONTINUE, -1); */
+ /* windows_continue (DBG_CONTINUE, -1); */
}
static void
-win32_mourn_inferior (struct target_ops *ops)
+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)
{
^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));
}
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)
{
{
DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
len, (DWORD) (uintptr_t) memaddr));
- if (!WriteProcessMemory (current_process_handle,
+ if (!WriteProcessMemory (current_process_handle,
(LPVOID) (uintptr_t) memaddr, our,
len, &done))
done = 0;
- FlushInstructionCache (current_process_handle,
+ FlushInstructionCache (current_process_handle,
(LPCVOID) (uintptr_t) memaddr, len);
}
else
{
DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
len, (DWORD) (uintptr_t) memaddr));
- if (!ReadProcessMemory (current_process_handle,
+ if (!ReadProcessMemory (current_process_handle,
(LPCVOID) (uintptr_t) memaddr, our,
len, &done))
done = 0;
}
static void
-win32_kill_inferior (void)
+windows_kill_inferior (struct target_ops *ops)
{
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;
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];
}
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)
obstack_init (&obstack);
obstack_grow_str (&obstack, "<library-list>\n");
for (so = solib_start.next; so; so = so->next)
- win32_xfer_shared_library (so->so_name, (CORE_ADDR) so->lm_info->load_addr,
- &obstack);
+ windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
+ target_gdbarch, &obstack);
obstack_grow_str0 (&obstack, "</library-list>\n");
buf = obstack_finish (&obstack);
}
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)
{
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:
}
}
+static ptid_t
+windows_get_ada_task_ptid (long lwp, long thread)
+{
+ return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
+}
+
static void
-init_win32_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;
+init_windows_ops (void)
+{
+ 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 = default_child_has_all_memory;
+ windows_ops.to_has_memory = default_child_has_memory;
+ windows_ops.to_has_stack = default_child_has_stack;
+ windows_ops.to_has_registers = default_child_has_registers;
+ windows_ops.to_has_execution = default_child_has_execution;
+ windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
+ windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;
+
+ i386_use_watchpoints (&windows_ops);
+
+ i386_dr_low.set_control = cygwin_set_dr7;
+ i386_dr_low.set_addr = cygwin_set_dr;
+ i386_dr_low.reset_addr = NULL;
+ i386_dr_low.get_status = cygwin_get_dr6;
+
+ /* i386_dr_low.debug_register_length field is set by
+ calling i386_set_debug_register_length function
+ in processor windows specific native file. */
+
+ 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."));
add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
+ add_com_alias ("add-shared-symbol-files", "dll-symbols", class_alias, 1);
+
+ add_com_alias ("assf", "dll-symbols", class_alias, 1);
+
#ifdef __CYGWIN__
add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
Set use of shell to start subprocess."), _("\
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. */
-void
+ actually set up when windows_continue is called. */
+static void
cygwin_set_dr (int i, CORE_ADDR addr)
{
if (i < 0 || i > 3)
internal_error (__FILE__, __LINE__,
_("Invalid register %d in cygwin_set_dr.\n"), i);
- dr[i] = (unsigned) addr;
+ dr[i] = addr;
debug_registers_changed = 1;
debug_registers_used = 1;
}
/* 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. */
-void
-cygwin_set_dr7 (unsigned val)
+ will be actually set up in windows_wait. */
+static void
+cygwin_set_dr7 (unsigned long val)
{
- dr[7] = val;
+ dr[7] = (CORE_ADDR) val;
debug_registers_changed = 1;
debug_registers_used = 1;
}
/* Get the value of the DR6 debug status register from the inferior.
Here we just return the value stored in dr[6]
by the last call to thread_rec for current_event.dwThreadId id. */
-unsigned
+static unsigned long
cygwin_get_dr6 (void)
{
- return dr[6];
+ return (unsigned long) dr[6];
}
/* Determine if the thread referenced by "ptid" is alive
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;
}
}
+/* Define dummy functions which always return error for the rare cases where
+ these functions could not be found. */
+static BOOL WINAPI
+bad_DebugActiveProcessStop (DWORD w)
+{
+ return FALSE;
+}
+static BOOL WINAPI
+bad_DebugBreakProcess (HANDLE w)
+{
+ return FALSE;
+}
+static BOOL WINAPI
+bad_DebugSetProcessKillOnExit (BOOL w)
+{
+ return FALSE;
+}
+static BOOL WINAPI
+bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
+{
+ return FALSE;
+}
+static DWORD WINAPI
+bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
+{
+ return 0;
+}
+static BOOL WINAPI
+bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
+{
+ return FALSE;
+}
+
+static BOOL WINAPI
+bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
+{
+ return FALSE;
+}
+
+/* Load any functions which may not be available in ancient versions
+ of Windows. */
void
-_initialize_psapi (void)
+_initialize_loadable (void)
{
+ HMODULE hm = NULL;
+
+ hm = LoadLibrary ("kernel32.dll");
+ if (hm)
+ {
+ dyn_DebugActiveProcessStop = (void *)
+ GetProcAddress (hm, "DebugActiveProcessStop");
+ dyn_DebugBreakProcess = (void *)
+ GetProcAddress (hm, "DebugBreakProcess");
+ dyn_DebugSetProcessKillOnExit = (void *)
+ GetProcAddress (hm, "DebugSetProcessKillOnExit");
+ }
+
+ /* Set variables to dummy versions of these processes if the function
+ wasn't found in kernel32.dll. */
+ if (!dyn_DebugBreakProcess)
+ dyn_DebugBreakProcess = bad_DebugBreakProcess;
+ if (!dyn_DebugActiveProcessStop || !dyn_DebugSetProcessKillOnExit)
+ {
+ dyn_DebugActiveProcessStop = bad_DebugActiveProcessStop;
+ dyn_DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
+ }
+
/* Load optional functions used for retrieving filename information
associated with the currently debugged process or its dlls. */
- if (!psapi_loaded)
+ hm = LoadLibrary ("psapi.dll");
+ if (hm)
{
- HMODULE psapi_module_handle;
-
- psapi_loaded = -1;
+ dyn_EnumProcessModules = (void *)
+ GetProcAddress (hm, "EnumProcessModules");
+ dyn_GetModuleInformation = (void *)
+ GetProcAddress (hm, "GetModuleInformation");
+ dyn_GetModuleFileNameExA = (void *)
+ GetProcAddress (hm, "GetModuleFileNameExA");
+ }
- psapi_module_handle = LoadLibrary ("psapi.dll");
- if (psapi_module_handle)
- {
- psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
- psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
- psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
-
- if (psapi_EnumProcessModules != NULL
- && psapi_GetModuleInformation != NULL
- && psapi_GetModuleFileNameExA != NULL)
- psapi_loaded = 1;
- }
+ if (!dyn_EnumProcessModules || !dyn_GetModuleInformation || !dyn_GetModuleFileNameExA)
+ {
+ /* Set variables to dummy versions of these processes if the function
+ wasn't found in psapi.dll. */
+ dyn_EnumProcessModules = bad_EnumProcessModules;
+ dyn_GetModuleInformation = bad_GetModuleInformation;
+ dyn_GetModuleFileNameExA = bad_GetModuleFileNameExA;
+ /* This will probably fail on Windows 9x/Me. Let the user know that we're
+ missing some functionality. */
+ warning(_("cannot automatically find executable file or library to read symbols.\nUse \"file\" or \"dll\" command to load executable/libraries directly."));
}
- /* This will probably fail on Windows 9x/Me. Let the user know that we're
- missing some functionality. */
- if (psapi_loaded < 0)
- warning(_("cannot automatically find executable file or library to read symbols. Use \"file\" or \"dll\" command to load executable/libraries directly."));
+ hm = LoadLibrary ("advapi32.dll");
+ if (hm)
+ {
+ dyn_OpenProcessToken = (void *)
+ GetProcAddress (hm, "OpenProcessToken");
+ dyn_LookupPrivilegeValueA = (void *)
+ GetProcAddress (hm, "LookupPrivilegeValueA");
+ dyn_AdjustTokenPrivileges = (void *)
+ GetProcAddress (hm, "AdjustTokenPrivileges");
+ /* Only need to set one of these since if OpenProcessToken fails nothing
+ else is needed. */
+ if (!dyn_OpenProcessToken || !dyn_LookupPrivilegeValueA || !dyn_AdjustTokenPrivileges)
+ dyn_OpenProcessToken = bad_OpenProcessToken;
+ }
}
projects / deliverable / binutils-gdb.git / blobdiff