/* Inferior process information for the remote server for GDB.
- Copyright 2002, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2017 Free Software Foundation, Inc.
Contributed by MontaVista Software.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
-
-#include <stdlib.h>
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "server.h"
+#include "gdbthread.h"
+#include "dll.h"
-struct thread_info
-{
- struct inferior_list_entry entry;
- void *target_data;
- void *regcache_data;
- unsigned int gdb_id;
-};
-
-struct inferior_list all_threads;
+std::list<process_info *> all_processes;
+std::list<thread_info *> all_threads;
-struct thread_info *current_inferior;
+struct thread_info *current_thread;
-#define get_thread(inf) ((struct thread_info *)(inf))
+/* The current working directory used to start the inferior. */
+static const char *current_inferior_cwd = NULL;
-void
-add_inferior_to_list (struct inferior_list *list,
- struct inferior_list_entry *new_inferior)
+thread_info *
+find_inferior (std::list<thread_info *> *thread_list,
+ int (*func) (thread_info *, void *),
+ void *arg)
{
- new_inferior->next = NULL;
- if (list->tail != NULL)
- list->tail->next = new_inferior;
- else
- list->head = new_inferior;
- list->tail = new_inferior;
+ gdb_assert (thread_list == &all_threads);
+
+ return find_thread ([&] (thread_info *thread) {
+ return func (thread, arg);
+ });
}
-void
-for_each_inferior (struct inferior_list *list,
- void (*action) (struct inferior_list_entry *))
+thread_info *
+find_inferior_in_random (std::list<thread_info *> *thread_list,
+ int (*func) (thread_info *, void *),
+ void *arg)
{
- struct inferior_list_entry *cur = list->head, *next;
+ gdb_assert (thread_list == &all_threads);
- while (cur != NULL)
- {
- next = cur->next;
- (*action) (cur);
- cur = next;
- }
+ return find_thread_in_random ([&] (thread_info *thread) {
+ return func (thread, arg);
+ });
}
void
-change_inferior_id (struct inferior_list *list,
- unsigned long new_id)
+for_each_inferior (std::list<thread_info *> *thread_list,
+ void (*action) (thread_info *))
{
- if (list->head != list->tail)
- error ("tried to change thread ID after multiple threads are created");
+ gdb_assert (thread_list == &all_threads);
- list->head->id = new_id;
+ for_each_thread ([&] (thread_info *thread) {
+ action (thread);
+ });
}
void
-remove_inferior (struct inferior_list *list,
- struct inferior_list_entry *entry)
+for_each_inferior_with_data (std::list<thread_info *> *thread_list,
+ void (*action) (thread_info *, void *),
+ void *data)
{
- struct inferior_list_entry **cur;
-
- if (list->head == entry)
- {
- list->head = entry->next;
- if (list->tail == entry)
- list->tail = list->head;
- return;
- }
+ gdb_assert (thread_list == &all_threads);
- cur = &list->head;
- while (*cur && (*cur)->next != entry)
- cur = &(*cur)->next;
-
- if (*cur == NULL)
- return;
-
- (*cur)->next = entry->next;
-
- if (list->tail == entry)
- list->tail = *cur;
+ for_each_thread ([&] (thread_info *thread) {
+ action (thread, data);
+ });
}
-void
-add_thread (unsigned long thread_id, void *target_data, unsigned int gdb_id)
+struct thread_info *
+add_thread (ptid_t thread_id, void *target_data)
{
- struct thread_info *new_thread
- = (struct thread_info *) malloc (sizeof (*new_thread));
+ struct thread_info *new_thread = XCNEW (struct thread_info);
- memset (new_thread, 0, sizeof (*new_thread));
+ new_thread->id = thread_id;
+ new_thread->last_resume_kind = resume_continue;
+ new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
- new_thread->entry.id = thread_id;
+ all_threads.push_back (new_thread);
- add_inferior_to_list (&all_threads, & new_thread->entry);
-
- if (current_inferior == NULL)
- current_inferior = new_thread;
+ if (current_thread == NULL)
+ current_thread = new_thread;
new_thread->target_data = target_data;
- set_inferior_regcache_data (new_thread, new_register_cache ());
- new_thread->gdb_id = gdb_id;
-}
-unsigned int
-thread_id_to_gdb_id (unsigned long thread_id)
-{
- struct inferior_list_entry *inf = all_threads.head;
+ return new_thread;
+}
- while (inf != NULL)
- {
- struct thread_info *thread = get_thread (inf);
- if (inf->id == thread_id)
- return thread->gdb_id;
- inf = inf->next;
- }
+/* See gdbthread.h. */
- return 0;
+struct thread_info *
+get_first_thread (void)
+{
+ if (!all_threads.empty ())
+ return all_threads.front ();
+ else
+ return NULL;
}
-unsigned int
-thread_to_gdb_id (struct thread_info *thread)
+struct thread_info *
+find_thread_ptid (ptid_t ptid)
{
- return thread->gdb_id;
+ return find_thread ([&] (thread_info *thread) {
+ return thread->id == ptid;
+ });
}
-unsigned long
-gdb_id_to_thread_id (unsigned int gdb_id)
+/* Find a thread associated with the given PROCESS, or NULL if no
+ such thread exists. */
+
+static struct thread_info *
+find_thread_process (const struct process_info *const process)
{
- struct inferior_list_entry *inf = all_threads.head;
+ return find_any_thread_of_pid (process->pid);
+}
- while (inf != NULL)
- {
- struct thread_info *thread = get_thread (inf);
- if (thread->gdb_id == gdb_id)
- return inf->id;
- inf = inf->next;
- }
+/* See gdbthread.h. */
- return 0;
+struct thread_info *
+find_any_thread_of_pid (int pid)
+{
+ return find_thread (pid, [] (thread_info *thread) {
+ return true;
+ });
}
static void
-free_one_thread (struct inferior_list_entry *inf)
+free_one_thread (thread_info *thread)
{
- struct thread_info *thread = get_thread (inf);
- free_register_cache (inferior_regcache_data (thread));
+ free_register_cache (thread_regcache_data (thread));
free (thread);
}
void
remove_thread (struct thread_info *thread)
{
- remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
- free_one_thread (&thread->entry);
+ if (thread->btrace != NULL)
+ target_disable_btrace (thread->btrace);
+
+ discard_queued_stop_replies (ptid_of (thread));
+ all_threads.remove (thread);
+ free_one_thread (thread);
+ if (current_thread == thread)
+ current_thread = NULL;
+}
+
+void *
+thread_target_data (struct thread_info *thread)
+{
+ return thread->target_data;
+}
+
+struct regcache *
+thread_regcache_data (struct thread_info *thread)
+{
+ return thread->regcache_data;
+}
+
+void
+set_thread_regcache_data (struct thread_info *thread, struct regcache *data)
+{
+ thread->regcache_data = data;
}
void
clear_inferiors (void)
{
for_each_inferior (&all_threads, free_one_thread);
+ all_threads.clear ();
+
+ clear_dlls ();
- all_threads.head = all_threads.tail = NULL;
+ current_thread = NULL;
}
-struct inferior_list_entry *
-find_inferior (struct inferior_list *list,
- int (*func) (struct inferior_list_entry *, void *), void *arg)
+struct process_info *
+add_process (int pid, int attached)
{
- struct inferior_list_entry *inf = list->head;
+ process_info *process = new process_info (pid, attached);
- while (inf != NULL)
- {
- if ((*func) (inf, arg))
- return inf;
- inf = inf->next;
- }
+ all_processes.push_back (process);
- return NULL;
+ return process;
}
-struct inferior_list_entry *
-find_inferior_id (struct inferior_list *list, unsigned long id)
+/* Remove a process from the common process list and free the memory
+ allocated for it.
+ The caller is responsible for freeing private data first. */
+
+void
+remove_process (struct process_info *process)
+{
+ clear_symbol_cache (&process->symbol_cache);
+ free_all_breakpoints (process);
+ gdb_assert (find_thread_process (process) == NULL);
+ all_processes.remove (process);
+ delete process;
+}
+
+process_info *
+find_process_pid (int pid)
+{
+ return find_process ([&] (process_info *process) {
+ return process->pid == pid;
+ });
+}
+
+/* Get the first process in the process list, or NULL if the list is empty. */
+
+process_info *
+get_first_process (void)
{
- struct inferior_list_entry *inf = list->head;
+ if (!all_processes.empty ())
+ return all_processes.front ();
+ else
+ return NULL;
+}
- while (inf != NULL)
- {
- if (inf->id == id)
- return inf;
- inf = inf->next;
- }
+/* Return non-zero if there are any inferiors that we have created
+ (as opposed to attached-to). */
- return NULL;
+int
+have_started_inferiors_p (void)
+{
+ return find_process ([] (process_info *process) {
+ return !process->attached;
+ }) != NULL;
}
-void *
-inferior_target_data (struct thread_info *inferior)
+/* Return non-zero if there are any inferiors that we have attached to. */
+
+int
+have_attached_inferiors_p (void)
+{
+ return find_process ([] (process_info *process) {
+ return process->attached;
+ }) != NULL;
+}
+
+struct process_info *
+get_thread_process (const struct thread_info *thread)
+{
+ return find_process_pid (thread->id.pid ());
+}
+
+struct process_info *
+current_process (void)
+{
+ gdb_assert (current_thread != NULL);
+ return get_thread_process (current_thread);
+}
+
+static void
+do_restore_current_thread_cleanup (void *arg)
{
- return inferior->target_data;
+ current_thread = (struct thread_info *) arg;
}
+struct cleanup *
+make_cleanup_restore_current_thread (void)
+{
+ return make_cleanup (do_restore_current_thread_cleanup, current_thread);
+}
+
+/* See common/common-gdbthread.h. */
+
void
-set_inferior_target_data (struct thread_info *inferior, void *data)
+switch_to_thread (ptid_t ptid)
{
- inferior->target_data = data;
+ gdb_assert (ptid != minus_one_ptid);
+ current_thread = find_thread_ptid (ptid);
}
-void *
-inferior_regcache_data (struct thread_info *inferior)
+/* See common/common-inferior.h. */
+
+const char *
+get_inferior_cwd ()
{
- return inferior->regcache_data;
+ return current_inferior_cwd;
}
+/* See common/common-inferior.h. */
+
void
-set_inferior_regcache_data (struct thread_info *inferior, void *data)
+set_inferior_cwd (const char *cwd)
{
- inferior->regcache_data = data;
+ xfree ((void *) current_inferior_cwd);
+ if (cwd != NULL)
+ current_inferior_cwd = xstrdup (cwd);
+ else
+ current_inferior_cwd = NULL;
}
projects / deliverable / binutils-gdb.git / blobdiff