#include <cygwin/version.h>
#endif
#include <algorithm>
+#include <vector>
#include "filenames.h"
#include "symfile.h"
#include "gdbsupport/gdb_tilde_expand.h"
#include "gdbsupport/pathstuff.h"
#include "gdbsupport/gdb_wait.h"
+#include "nat/windows-nat.h"
#define STATUS_WX86_BREAKPOINT 0x4000001F
#define STATUS_WX86_SINGLE_STEP 0x4000001E
static enum gdb_signal last_sig = GDB_SIGNAL_0;
/* Set if a signal was received from the debugged process. */
-/* Thread information structure used to track information that is
- not available in gdb's thread structure. */
-typedef struct windows_thread_info_struct
- {
- struct windows_thread_info_struct *next;
- DWORD id;
- HANDLE h;
- CORE_ADDR thread_local_base;
- char *name;
- int suspended;
- int reload_context;
- union
- {
- CONTEXT context;
-#ifdef __x86_64__
- WOW64_CONTEXT wow64_context;
-#endif
- };
- }
-windows_thread_info;
-
-static windows_thread_info thread_head;
+static std::vector<windows_thread_info *> thread_list;
/* The process and thread handles for the above context. */
static windows_thread_info *
thread_rec (DWORD id, int get_context)
{
- windows_thread_info *th;
-
- for (th = &thread_head; (th = th->next) != NULL;)
- if (th->id == id)
+ for (windows_thread_info *th : thread_list)
+ if (th->tid == id)
{
if (!th->suspended && get_context)
{
if (get_context > 0 && id != current_event.dwThreadId)
- {
- if (SuspendThread (th->h) == (DWORD) -1)
- {
- DWORD err = GetLastError ();
-
- /* We get Access Denied (5) when trying to suspend
- threads that Windows started on behalf of the
- debuggee, usually when those threads are just
- about to exit.
- We can get Invalid Handle (6) if the main thread
- has exited. */
- if (err != ERROR_INVALID_HANDLE
- && err != ERROR_ACCESS_DENIED)
- warning (_("SuspendThread (tid=0x%x) failed."
- " (winerr %u)"),
- (unsigned) id, (unsigned) err);
- th->suspended = -1;
- }
- else
- th->suspended = 1;
- }
+ th->suspend ();
else if (get_context < 0)
th->suspended = -1;
- th->reload_context = 1;
+ th->reload_context = true;
}
return th;
}
windows_thread_info *th;
DWORD id;
- gdb_assert (ptid.tid () != 0);
+ gdb_assert (ptid.lwp () != 0);
- id = ptid.tid ();
+ id = ptid.lwp ();
if ((th = thread_rec (id, FALSE)))
return th;
- th = XCNEW (windows_thread_info);
- th->id = id;
- th->h = h;
- th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
+ CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb;
#ifdef __x86_64__
/* For WOW64 processes, this is actually the pointer to the 64bit TIB,
and the 32bit TIB is exactly 2 pages after it. */
if (wow64_process)
- th->thread_local_base += 0x2000;
+ base += 0x2000;
#endif
- th->next = thread_head.next;
- thread_head.next = th;
+ th = new windows_thread_info (id, h, base);
+ thread_list.push_back (th);
/* Add this new thread to the list of threads.
static void
windows_init_thread_list (void)
{
- windows_thread_info *th = &thread_head;
-
DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
init_thread_list ();
- while (th->next != NULL)
- {
- windows_thread_info *here = th->next;
- th->next = here->next;
- xfree (here);
- }
- thread_head.next = NULL;
+
+ for (windows_thread_info *here : thread_list)
+ delete here;
+
+ thread_list.clear ();
}
/* Delete a thread from the list of threads.
static void
windows_delete_thread (ptid_t ptid, DWORD exit_code, bool main_thread_p)
{
- windows_thread_info *th;
DWORD id;
- gdb_assert (ptid.tid () != 0);
+ gdb_assert (ptid.lwp () != 0);
- id = ptid.tid ();
+ id = ptid.lwp ();
/* Emit a notification about the thread being deleted.
delete_thread (find_thread_ptid (&the_windows_nat_target, ptid));
- for (th = &thread_head;
- th->next != NULL && th->next->id != id;
- th = th->next)
- continue;
+ auto iter = std::find_if (thread_list.begin (), thread_list.end (),
+ [=] (windows_thread_info *th)
+ {
+ return th->tid == id;
+ });
- if (th->next != NULL)
+ if (iter != thread_list.end ())
{
- windows_thread_info *here = th->next;
- th->next = here->next;
- xfree (here->name);
- xfree (here);
+ delete *iter;
+ thread_list.erase (iter);
}
}
void
windows_nat_target::fetch_registers (struct regcache *regcache, int r)
{
- DWORD tid = regcache->ptid ().tid ();
+ DWORD tid = regcache->ptid ().lwp ();
windows_thread_info *th = thread_rec (tid, TRUE);
/* Check if TH exists. Windows sometimes uses a non-existent
dr[7] = th->context.Dr7;
}
}
- th->reload_context = 0;
+ th->reload_context = false;
}
if (r < 0)
void
windows_nat_target::store_registers (struct regcache *regcache, int r)
{
- DWORD tid = regcache->ptid ().tid ();
+ DWORD tid = regcache->ptid ().lwp ();
windows_thread_info *th = thread_rec (tid, TRUE);
/* Check if TH exists. Windows sometimes uses a non-existent
if (thread_name_len > 0)
{
thread_name.get ()[thread_name_len - 1] = '\0';
- xfree (named_thread->name);
- named_thread->name = thread_name.release ();
+ named_thread->name = std::move (thread_name);
}
}
ourstatus->value.sig = GDB_SIGNAL_TRAP;
static BOOL
windows_continue (DWORD continue_status, int id, int killed)
{
- windows_thread_info *th;
BOOL res;
DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
continue_status == DBG_CONTINUE ?
"DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
- for (th = &thread_head; (th = th->next) != NULL;)
- if ((id == -1 || id == (int) th->id)
+ for (windows_thread_info *th : thread_list)
+ if ((id == -1 || id == (int) th->tid)
&& th->suspended)
{
#ifdef __x86_64__
th->context.ContextFlags = 0;
}
}
- if (th->suspended > 0)
- (void) ResumeThread (th->h);
- th->suspended = 0;
+ th->resume ();
}
res = ContinueDebugEvent (current_event.dwProcessId,
/* We can not debug anything in that case. */
}
current_thread
- = windows_add_thread (ptid_t (current_event.dwProcessId, 0,
- current_event.dwThreadId),
+ = windows_add_thread (ptid_t (current_event.dwProcessId,
+ current_event.dwThreadId, 0),
current_event.u.CreateThread.hThread,
current_event.u.CreateThread.lpThreadLocalBase,
true /* main_thread_p */);
last_sig = GDB_SIGNAL_0;
DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n",
- ptid.pid (), (unsigned) ptid.tid (), step, sig));
+ ptid.pid (), (unsigned) ptid.lwp (), step, sig));
/* Get context for currently selected thread. */
- th = thread_rec (inferior_ptid.tid (), FALSE);
+ th = thread_rec (inferior_ptid.lwp (), FALSE);
if (th)
{
#ifdef __x86_64__
if (resume_all)
windows_continue (continue_status, -1, 0);
else
- windows_continue (continue_status, ptid.tid (), 0);
+ windows_continue (continue_status, ptid.lwp (), 0);
}
/* Ctrl-C handler used when the inferior is not run in the same console. The
BOOL debug_event;
DWORD continue_status, event_code;
windows_thread_info *th;
- static windows_thread_info dummy_thread_info;
+ static windows_thread_info dummy_thread_info (0, 0, 0);
DWORD thread_id = 0;
last_sig = GDB_SIGNAL_0;
/* Record the existence of this thread. */
thread_id = current_event.dwThreadId;
th = windows_add_thread
- (ptid_t (current_event.dwProcessId, 0, current_event.dwThreadId),
+ (ptid_t (current_event.dwProcessId, current_event.dwThreadId, 0),
current_event.u.CreateThread.hThread,
current_event.u.CreateThread.lpThreadLocalBase,
false /* main_thread_p */);
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
"EXIT_THREAD_DEBUG_EVENT"));
- windows_delete_thread (ptid_t (current_event.dwProcessId, 0,
- current_event.dwThreadId),
+ windows_delete_thread (ptid_t (current_event.dwProcessId,
+ current_event.dwThreadId, 0),
current_event.u.ExitThread.dwExitCode,
false /* main_thread_p */);
th = &dummy_thread_info;
current_process_handle = current_event.u.CreateProcessInfo.hProcess;
/* Add the main thread. */
th = windows_add_thread
- (ptid_t (current_event.dwProcessId, 0,
- current_event.dwThreadId),
+ (ptid_t (current_event.dwProcessId,
+ current_event.dwThreadId, 0),
current_event.u.CreateProcessInfo.hThread,
current_event.u.CreateProcessInfo.lpThreadLocalBase,
true /* main_thread_p */);
}
else if (saw_create == 1)
{
- windows_delete_thread (ptid_t (current_event.dwProcessId, 0,
- current_event.dwThreadId),
+ windows_delete_thread (ptid_t (current_event.dwProcessId,
+ current_event.dwThreadId, 0),
0, true /* main_thread_p */);
DWORD exit_status = current_event.u.ExitProcess.dwExitCode;
/* If the exit status looks like a fatal exception, but we
}
else
{
- inferior_ptid = ptid_t (current_event.dwProcessId, 0, thread_id);
+ inferior_ptid = ptid_t (current_event.dwProcessId, thread_id, 0);
current_thread = th;
if (!current_thread)
current_thread = thread_rec (thread_id, TRUE);
SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);
if (retval)
- return ptid_t (current_event.dwProcessId, 0, retval);
+ return ptid_t (current_event.dwProcessId, retval, 0);
else
{
int detach = 0;
return;
}
-#ifdef __x86_64__
char system_dir[__PMAX];
char syswow_dir[__PMAX];
size_t system_dir_len = 0;
+ bool convert_syswow_dir = false;
+#ifdef __x86_64__
if (wow64_process)
+#endif
{
- UINT len = GetSystemDirectoryA (system_dir, sizeof (system_dir));
- /* Error check. */
- gdb_assert (len != 0);
- /* Check that we have passed a large enough buffer. */
- gdb_assert (len < sizeof (system_dir));
+ /* This fails on 32bit Windows because it has no SysWOW64 directory,
+ and in this case a path conversion isn't necessary. */
+ UINT len = GetSystemWow64DirectoryA (syswow_dir, sizeof (syswow_dir));
+ if (len > 0)
+ {
+ /* Check that we have passed a large enough buffer. */
+ gdb_assert (len < sizeof (syswow_dir));
+
+ len = GetSystemDirectoryA (system_dir, sizeof (system_dir));
+ /* Error check. */
+ gdb_assert (len != 0);
+ /* Check that we have passed a large enough buffer. */
+ gdb_assert (len < sizeof (system_dir));
- len = GetSystemWow64DirectoryA (syswow_dir, sizeof (syswow_dir));
- /* Error check. */
- gdb_assert (len != 0);
- /* Check that we have passed a large enough buffer. */
- gdb_assert (len < sizeof (syswow_dir));
+ strcat (system_dir, "\\");
+ strcat (syswow_dir, "\\");
+ system_dir_len = strlen (system_dir);
+
+ convert_syswow_dir = true;
+ }
- strcat (system_dir, "\\");
- strcat (syswow_dir, "\\");
- system_dir_len = strlen (system_dir);
}
-#endif
for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
{
MODULEINFO mi;
#else
name = dll_name;
#endif
-#ifdef __x86_64__
- /* Convert the DLL path of WOW64 processes returned by
+ /* Convert the DLL path of 32bit processes returned by
GetModuleFileNameEx from the 64bit system directory to the
32bit syswow64 directory if necessary. */
std::string syswow_dll_path;
- if (wow64_process
+ if (convert_syswow_dir
&& strncasecmp (name, system_dir, system_dir_len) == 0
&& strchr (name + system_dir_len, '\\') == nullptr)
{
syswow_dll_path += name + system_dir_len;
name = syswow_dll_path.c_str();
}
-#endif
solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
solib_end = solib_end->next;
std::string
windows_nat_target::pid_to_str (ptid_t ptid)
{
- if (ptid.tid () != 0)
- return string_printf ("Thread %d.0x%lx", ptid.pid (), ptid.tid ());
+ if (ptid.lwp () != 0)
+ return string_printf ("Thread %d.0x%lx", ptid.pid (), ptid.lwp ());
return normal_pid_to_str (ptid);
}
{
windows_thread_info *th;
- th = thread_rec (ptid.tid (), 0);
+ th = thread_rec (ptid.lwp (), 0);
if (th == NULL)
return false;
ptid_t
windows_nat_target::get_ada_task_ptid (long lwp, long thread)
{
- return ptid_t (inferior_ptid.pid (), 0, lwp);
+ return ptid_t (inferior_ptid.pid (), lwp, 0);
}
/* Implementation of the to_thread_name method. */
const char *
windows_nat_target::thread_name (struct thread_info *thr)
{
- return thread_rec (thr->ptid.tid (), 0)->name;
+ return thread_rec (thr->ptid.lwp (), 0)->name.get ();
}
{
int tid;
- gdb_assert (ptid.tid () != 0);
- tid = ptid.tid ();
+ gdb_assert (ptid.lwp () != 0);
+ tid = ptid.lwp ();
return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) != WAIT_OBJECT_0;
}
projects / deliverable / binutils-gdb.git / blobdiff