/* Inferior process information for the remote server for GDB.
- Copyright 2002, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2020 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"
+
+std::list<process_info *> all_processes;
+std::list<thread_info *> all_threads;
+
+struct thread_info *current_thread;
+
+/* The current working directory used to start the inferior. */
+static const char *current_inferior_cwd = NULL;
-struct thread_info
+struct thread_info *
+add_thread (ptid_t thread_id, void *target_data)
{
- struct inferior_list_entry entry;
- void *target_data;
- void *regcache_data;
-};
+ struct thread_info *new_thread = XCNEW (struct thread_info);
-struct inferior_list all_threads;
+ new_thread->id = thread_id;
+ new_thread->last_resume_kind = resume_continue;
+ new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
-struct thread_info *current_inferior;
+ all_threads.push_back (new_thread);
-#define get_thread(inf) ((struct thread_info *)(inf))
+ if (current_thread == NULL)
+ current_thread = new_thread;
-void
-add_inferior_to_list (struct inferior_list *list,
- struct inferior_list_entry *new_inferior)
+ new_thread->target_data = target_data;
+
+ return new_thread;
+}
+
+/* See gdbthread.h. */
+
+struct thread_info *
+get_first_thread (void)
{
- new_inferior->next = NULL;
- if (list->tail != NULL)
- list->tail->next = new_inferior;
+ if (!all_threads.empty ())
+ return all_threads.front ();
else
- list->head = new_inferior;
- list->tail = new_inferior;
+ return NULL;
}
-void
-for_each_inferior (struct inferior_list *list,
- void (*action) (struct inferior_list_entry *))
+struct thread_info *
+find_thread_ptid (ptid_t ptid)
{
- struct inferior_list_entry *cur = list->head, *next;
+ return find_thread ([&] (thread_info *thread) {
+ return thread->id == ptid;
+ });
+}
- while (cur != NULL)
- {
- next = cur->next;
- (*action) (cur);
- cur = next;
- }
+/* 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)
+{
+ return find_any_thread_of_pid (process->pid);
}
-void
-change_inferior_id (struct inferior_list *list,
- unsigned long new_id)
+/* See gdbthread.h. */
+
+struct thread_info *
+find_any_thread_of_pid (int pid)
{
- if (list->head != list->tail)
- error ("tried to change thread ID after multiple threads are created");
+ return find_thread (pid, [] (thread_info *thread) {
+ return true;
+ });
+}
- list->head->id = new_id;
+static void
+free_one_thread (thread_info *thread)
+{
+ free_register_cache (thread_regcache_data (thread));
+ free (thread);
}
void
-remove_inferior (struct inferior_list *list,
- struct inferior_list_entry *entry)
+remove_thread (struct thread_info *thread)
{
- struct inferior_list_entry **cur;
-
- if (list->head == entry)
- {
- list->head = entry->next;
- if (list->tail == entry)
- list->tail = list->head;
- return;
- }
-
- cur = &list->head;
- while (*cur && (*cur)->next != entry)
- cur = &(*cur)->next;
-
- if (*cur == NULL)
- return;
+ 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;
+}
- (*cur)->next = entry->next;
+void *
+thread_target_data (struct thread_info *thread)
+{
+ return thread->target_data;
+}
- if (list->tail == entry)
- list->tail = *cur;
+struct regcache *
+thread_regcache_data (struct thread_info *thread)
+{
+ return thread->regcache_data;
}
void
-add_thread (unsigned long thread_id, void *target_data)
+set_thread_regcache_data (struct thread_info *thread, struct regcache *data)
{
- struct thread_info *new_thread
- = (struct thread_info *) malloc (sizeof (*new_thread));
-
- memset (new_thread, 0, sizeof (*new_thread));
+ thread->regcache_data = data;
+}
- new_thread->entry.id = thread_id;
+void
+clear_inferiors (void)
+{
+ for_each_thread (free_one_thread);
+ all_threads.clear ();
- add_inferior_to_list (&all_threads, & new_thread->entry);
-
- if (current_inferior == NULL)
- current_inferior = new_thread;
+ clear_dlls ();
- new_thread->target_data = target_data;
- set_inferior_regcache_data (new_thread, new_register_cache ());
+ current_thread = NULL;
}
-static void
-free_one_thread (struct inferior_list_entry *inf)
+struct process_info *
+add_process (int pid, int attached)
{
- struct thread_info *thread = get_thread (inf);
- free_register_cache (inferior_regcache_data (thread));
- free (thread);
+ process_info *process = new process_info (pid, attached);
+
+ all_processes.push_back (process);
+
+ return process;
}
+/* 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_thread (struct thread_info *thread)
+remove_process (struct process_info *process)
{
- remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
- free_one_thread (&thread->entry);
+ clear_symbol_cache (&process->symbol_cache);
+ free_all_breakpoints (process);
+ gdb_assert (find_thread_process (process) == NULL);
+ all_processes.remove (process);
+ delete process;
}
-void
-clear_inferiors (void)
+process_info *
+find_process_pid (int pid)
{
- for_each_inferior (&all_threads, free_one_thread);
-
- all_threads.head = all_threads.tail = NULL;
+ return find_process ([&] (process_info *process) {
+ return process->pid == pid;
+ });
}
-struct inferior_list_entry *
-find_inferior (struct inferior_list *list,
- int (*func) (struct inferior_list_entry *, void *), void *arg)
+/* 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 ((*func) (inf, arg))
- 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;
}
-struct inferior_list_entry *
-find_inferior_id (struct inferior_list *list, unsigned long id)
-{
- struct inferior_list_entry *inf = list->head;
+/* Return non-zero if there are any inferiors that we have attached to. */
- while (inf != NULL)
- {
- if (inf->id == id)
- return inf;
- inf = inf->next;
- }
+int
+have_attached_inferiors_p (void)
+{
+ return find_process ([] (process_info *process) {
+ return process->attached;
+ }) != NULL;
+}
- return NULL;
+struct process_info *
+get_thread_process (const struct thread_info *thread)
+{
+ return find_process_pid (thread->id.pid ());
}
-void *
-inferior_target_data (struct thread_info *inferior)
+struct process_info *
+current_process (void)
{
- return inferior->target_data;
+ gdb_assert (current_thread != NULL);
+ return get_thread_process (current_thread);
}
+/* See gdbsupport/common-gdbthread.h. */
+
void
-set_inferior_target_data (struct thread_info *inferior, void *data)
+switch_to_thread (process_stratum_target *ops, 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 gdbsupport/common-inferior.h. */
+
+const char *
+get_inferior_cwd ()
{
- return inferior->regcache_data;
+ return current_inferior_cwd;
}
+/* See gdbsupport/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