#include "gdbsupport/common-inferior.h"
#include "gdbsupport/gdb_wait.h"
+using namespace windows_nat;
+
#ifndef USE_WIN32API
#include <sys/cygwin.h>
#endif
/* Get the thread context of the thread associated with TH. */
static void
-win32_get_thread_context (win32_thread_info *th)
+win32_get_thread_context (windows_thread_info *th)
{
memset (&th->context, 0, sizeof (CONTEXT));
(*the_low_target.get_thread_context) (th);
/* Set the thread context of the thread associated with TH. */
static void
-win32_set_thread_context (win32_thread_info *th)
+win32_set_thread_context (windows_thread_info *th)
{
#ifdef _WIN32_WCE
/* Calling SuspendThread on a thread that is running kernel code
/* Set the thread context of the thread associated with TH. */
static void
-win32_prepare_to_resume (win32_thread_info *th)
+win32_prepare_to_resume (windows_thread_info *th)
{
if (the_low_target.prepare_to_resume != NULL)
(*the_low_target.prepare_to_resume) (th);
/* See win32-low.h. */
void
-win32_require_context (win32_thread_info *th)
+win32_require_context (windows_thread_info *th)
{
if (th->context.ContextFlags == 0)
{
- if (!th->suspended)
- {
- if (SuspendThread (th->h) == (DWORD) -1)
- {
- DWORD err = GetLastError ();
- OUTMSG (("warning: SuspendThread failed in thread_rec, "
- "(error %d): %s\n", (int) err, strwinerror (err)));
- }
- else
- th->suspended = 1;
- }
-
+ th->suspend ();
win32_get_thread_context (th);
}
}
-/* Find a thread record given a thread id. If GET_CONTEXT is set then
- also retrieve the context for this thread. */
-static win32_thread_info *
-thread_rec (ptid_t ptid, int get_context)
+/* See nat/windows-nat.h. */
+
+windows_thread_info *
+windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition)
{
thread_info *thread = find_thread_ptid (ptid);
if (thread == NULL)
return NULL;
- win32_thread_info *th = (win32_thread_info *) thread_target_data (thread);
- if (get_context)
+ windows_thread_info *th = (windows_thread_info *) thread_target_data (thread);
+ if (disposition != DONT_INVALIDATE_CONTEXT)
win32_require_context (th);
return th;
}
/* Add a thread to the thread list. */
-static win32_thread_info *
+static windows_thread_info *
child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb)
{
- win32_thread_info *th;
+ windows_thread_info *th;
ptid_t ptid = ptid_t (pid, tid, 0);
- if ((th = thread_rec (ptid, FALSE)))
+ if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
return th;
- th = XCNEW (win32_thread_info);
- th->tid = tid;
- th->h = h;
- th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
+ th = new windows_thread_info (tid, h, (CORE_ADDR) (uintptr_t) tlb);
add_thread (ptid, th);
static void
delete_thread_info (thread_info *thread)
{
- win32_thread_info *th = (win32_thread_info *) thread_target_data (thread);
+ windows_thread_info *th = (windows_thread_info *) thread_target_data (thread);
remove_thread (thread);
- CloseHandle (th->h);
- free (th);
+ delete th;
}
/* Delete a thread from the list of threads. */
/* These watchpoint related wrapper functions simply pass on the function call
if the low target has registered a corresponding function. */
-static int
-win32_supports_z_point_type (char z_type)
+bool
+win32_process_target::supports_z_point_type (char z_type)
{
return (the_low_target.supports_z_point_type != NULL
&& the_low_target.supports_z_point_type (z_type));
}
-static int
-win32_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
- int size, struct raw_breakpoint *bp)
+int
+win32_process_target::insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
+ int size, raw_breakpoint *bp)
{
if (the_low_target.insert_point != NULL)
return the_low_target.insert_point (type, addr, size, bp);
return 1;
}
-static int
-win32_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
- int size, struct raw_breakpoint *bp)
+int
+win32_process_target::remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
+ int size, raw_breakpoint *bp)
{
if (the_low_target.remove_point != NULL)
return the_low_target.remove_point (type, addr, size, bp);
return 1;
}
-static int
-win32_stopped_by_watchpoint (void)
+bool
+win32_process_target::stopped_by_watchpoint ()
{
if (the_low_target.stopped_by_watchpoint != NULL)
return the_low_target.stopped_by_watchpoint ();
else
- return 0;
+ return false;
}
-static CORE_ADDR
-win32_stopped_data_address (void)
+CORE_ADDR
+win32_process_target::stopped_data_address ()
{
if (the_low_target.stopped_data_address != NULL)
return the_low_target.stopped_data_address ();
{
struct target_waitstatus status;
- the_target->pt->wait (minus_one_ptid, &status, 0);
+ the_target->wait (minus_one_ptid, &status, 0);
/* Note win32_wait doesn't return thread events. */
if (status.kind != TARGET_WAITKIND_LOADED)
resume.kind = resume_continue;
resume.sig = 0;
- the_target->pt->resume (&resume, 1);
+ the_target->resume (&resume, 1);
}
}
static void
continue_one_thread (thread_info *thread, int thread_id)
{
- win32_thread_info *th = (win32_thread_info *) thread_target_data (thread);
+ windows_thread_info *th = (windows_thread_info *) thread_target_data (thread);
if (thread_id == -1 || thread_id == th->tid)
{
th->context.ContextFlags = 0;
}
- if (ResumeThread (th->h) == (DWORD) -1)
- {
- DWORD err = GetLastError ();
- OUTMSG (("warning: ResumeThread failed in continue_one_thread, "
- "(error %d): %s\n", (int) err, strwinerror (err)));
- }
- th->suspended = 0;
+ th->resume ();
}
}
}
child_fetch_inferior_registers (struct regcache *regcache, int r)
{
int regno;
- win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE);
+ windows_thread_info *th = thread_rec (current_thread_ptid (),
+ INVALIDATE_CONTEXT);
if (r == -1 || r > NUM_REGS)
child_fetch_inferior_registers (regcache, NUM_REGS);
else
child_store_inferior_registers (struct regcache *regcache, int r)
{
int regno;
- win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE);
+ windows_thread_info *th = thread_rec (current_thread_ptid (),
+ INVALIDATE_CONTEXT);
if (r == -1 || r == 0 || r > NUM_REGS)
child_store_inferior_registers (regcache, NUM_REGS);
else
DWORD tid;
enum gdb_signal sig;
int step;
- win32_thread_info *th;
+ windows_thread_info *th;
DWORD continue_status = DBG_CONTINUE;
ptid_t ptid;
/* Get context for the currently selected thread. */
ptid = debug_event_ptid (¤t_event);
- th = thread_rec (ptid, FALSE);
+ th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th)
{
win32_prepare_to_resume (th);
loaded_dll (buf2, load_addr);
}
-static char *
-get_image_name (HANDLE h, void *address, int unicode)
-{
- static char buf[(2 * MAX_PATH) + 1];
- DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
- char *address_ptr;
- int len = 0;
- char b[2];
- SIZE_T done;
-
- /* Attempt to read the name of the dll that was detected.
- This is documented to work only when actively debugging
- a program. It will not work for attached processes. */
- if (address == NULL)
- return NULL;
-
-#ifdef _WIN32_WCE
- /* Windows CE reports the address of the image name,
- instead of an address of a pointer into the image name. */
- address_ptr = address;
-#else
- /* See if we could read the address of a string, and that the
- address isn't null. */
- if (!ReadProcessMemory (h, address, &address_ptr,
- sizeof (address_ptr), &done)
- || done != sizeof (address_ptr)
- || !address_ptr)
- return NULL;
-#endif
-
- /* Find the length of the string */
- while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
- && (b[0] != 0 || b[size - 1] != 0) && done == size)
- continue;
-
- if (!unicode)
- ReadProcessMemory (h, address_ptr, buf, len, &done);
- else
- {
- WCHAR *unicode_address = XALLOCAVEC (WCHAR, len);
- ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
- &done);
-
- WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
- }
-
- return buf;
-}
-
typedef BOOL (WINAPI *winapi_EnumProcessModules) (HANDLE, HMODULE *,
DWORD, LPDWORD);
typedef BOOL (WINAPI *winapi_GetModuleInformation) (HANDLE, HMODULE,
handle_load_dll (void)
{
LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
- char *dll_name;
+ const char *dll_name;
dll_name = get_image_name (current_process_handle,
event->lpImageName, event->fUnicode);
static void
suspend_one_thread (thread_info *thread)
{
- win32_thread_info *th = (win32_thread_info *) thread_target_data (thread);
+ windows_thread_info *th = (windows_thread_info *) thread_target_data (thread);
- if (!th->suspended)
- {
- if (SuspendThread (th->h) == (DWORD) -1)
- {
- DWORD err = GetLastError ();
- OUTMSG (("warning: SuspendThread failed in suspend_one_thread, "
- "(error %d): %s\n", (int) err, strwinerror (err)));
- }
- else
- th->suspended = 1;
- }
+ th->suspend ();
}
static void
soft_interrupt_requested = 1;
}
+bool
+win32_process_target::supports_hardware_single_step ()
+{
+ return true;
+}
+
#ifdef _WIN32_WCE
int
win32_error_to_fileio_error (DWORD err)
return FILEIO_EUNKNOWN;
}
-static void
-wince_hostio_last_error (char *buf)
+void
+win32_process_target::hostio_last_error (char *buf)
{
DWORD winerr = GetLastError ();
int fileio_err = win32_error_to_fileio_error (winerr);
}
#endif
+bool
+win32_process_target::supports_qxfer_siginfo ()
+{
+ return true;
+}
+
/* Write Windows signal info. */
-static int
-win32_xfer_siginfo (const char *annex, unsigned char *readbuf,
- unsigned const char *writebuf, CORE_ADDR offset, int len)
+int
+win32_process_target::qxfer_siginfo (const char *annex,
+ unsigned char *readbuf,
+ unsigned const char *writebuf,
+ CORE_ADDR offset, int len)
{
if (siginfo_er.ExceptionCode == 0)
return -1;
return len;
}
+bool
+win32_process_target::supports_get_tib_address ()
+{
+ return true;
+}
+
/* Write Windows OS Thread Information Block address. */
-static int
-win32_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
+int
+win32_process_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
- win32_thread_info *th;
- th = thread_rec (ptid, 0);
+ windows_thread_info *th;
+ th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th == NULL)
return 0;
if (addr != NULL)
/* Implementation of the target_ops method "sw_breakpoint_from_kind". */
-static const gdb_byte *
-win32_sw_breakpoint_from_kind (int kind, int *size)
+const gdb_byte *
+win32_process_target::sw_breakpoint_from_kind (int kind, int *size)
{
*size = the_low_target.breakpoint_len;
return the_low_target.breakpoint;
static win32_process_target the_win32_target;
-static process_stratum_target win32_target_ops = {
- NULL, /* read_auxv */
- win32_supports_z_point_type,
- win32_insert_point,
- win32_remove_point,
- NULL, /* stopped_by_sw_breakpoint */
- NULL, /* supports_stopped_by_sw_breakpoint */
- NULL, /* stopped_by_hw_breakpoint */
- NULL, /* supports_stopped_by_hw_breakpoint */
- target_can_do_hardware_single_step,
- win32_stopped_by_watchpoint,
- win32_stopped_data_address,
- NULL, /* read_offsets */
- NULL, /* get_tls_address */
-#ifdef _WIN32_WCE
- wince_hostio_last_error,
-#else
- hostio_last_error_from_errno,
-#endif
- NULL, /* qxfer_osdata */
- win32_xfer_siginfo,
- NULL, /* supports_non_stop */
- NULL, /* async */
- NULL, /* start_non_stop */
- NULL, /* supports_multi_process */
- NULL, /* supports_fork_events */
- NULL, /* supports_vfork_events */
- NULL, /* supports_exec_events */
- NULL, /* handle_new_gdb_connection */
- NULL, /* handle_monitor_command */
- NULL, /* core_of_thread */
- NULL, /* read_loadmap */
- NULL, /* process_qsupported */
- NULL, /* supports_tracepoints */
- NULL, /* read_pc */
- NULL, /* write_pc */
- NULL, /* thread_stopped */
- win32_get_tib_address,
- NULL, /* pause_all */
- NULL, /* unpause_all */
- NULL, /* stabilize_threads */
- NULL, /* install_fast_tracepoint_jump_pad */
- NULL, /* emit_ops */
- NULL, /* supports_disable_randomization */
- NULL, /* get_min_fast_tracepoint_insn_len */
- NULL, /* qxfer_libraries_svr4 */
- NULL, /* support_agent */
- NULL, /* enable_btrace */
- NULL, /* disable_btrace */
- NULL, /* read_btrace */
- NULL, /* read_btrace_conf */
- NULL, /* supports_range_stepping */
- NULL, /* pid_to_exec_file */
- NULL, /* multifs_open */
- NULL, /* multifs_unlink */
- NULL, /* multifs_readlink */
- NULL, /* breakpoint_kind_from_pc */
- win32_sw_breakpoint_from_kind,
- NULL, /* thread_name */
- NULL, /* breakpoint_kind_from_current_state */
- NULL, /* supports_software_single_step */
- NULL, /* supports_catch_syscall */
- NULL, /* get_ipa_tdesc_idx */
- NULL, /* thread_handle */
- &the_win32_target,
-};
-
/* Initialize the Win32 backend. */
void
initialize_low (void)
{
- set_target_ops (&win32_target_ops);
+ set_target_ops (&the_win32_target);
the_low_target.arch_setup ();
}
projects / deliverable / binutils-gdb.git / blobdiff