/* Inferior process information for the remote server for GDB.
- Copyright (C) 2002, 2005, 2007 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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
-
-#include <stdlib.h>
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "server.h"
+#include "gdbsupport/common-inferior.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;
-struct inferior_list all_dlls;
-int dlls_changed;
+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))
-#define get_dll(inf) ((struct dll_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)
-{
- new_inferior->next = NULL;
- if (list->tail != NULL)
- list->tail->next = new_inferior;
- else
- list->head = new_inferior;
- list->tail = new_inferior;
-}
-
-void
-for_each_inferior (struct inferior_list *list,
- void (*action) (struct inferior_list_entry *))
-{
- struct inferior_list_entry *cur = list->head, *next;
-
- while (cur != NULL)
- {
- next = cur->next;
- (*action) (cur);
- cur = next;
- }
-}
-
-/* When debugging a single-threaded program, the threads list (such as
- it is) is indexed by PID. When debugging a multi-threaded program,
- we index by TID. This ugly routine replaces the
- first-debugged-thread's PID with its TID. */
-
-void
-change_inferior_id (struct inferior_list *list,
- unsigned long new_id)
+struct thread_info *
+add_thread (ptid_t thread_id, void *target_data)
{
- if (list->head != list->tail)
- error ("tried to change thread ID after multiple threads are created");
+ struct thread_info *new_thread = XCNEW (struct thread_info);
- list->head->id = new_id;
-}
+ new_thread->id = thread_id;
+ new_thread->last_resume_kind = resume_continue;
+ new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
-void
-remove_inferior (struct inferior_list *list,
- struct inferior_list_entry *entry)
-{
- struct inferior_list_entry **cur;
+ all_threads.push_back (new_thread);
- if (list->head == entry)
- {
- list->head = entry->next;
- if (list->tail == entry)
- list->tail = list->head;
- return;
- }
+ if (current_thread == NULL)
+ current_thread = new_thread;
- cur = &list->head;
- while (*cur && (*cur)->next != entry)
- cur = &(*cur)->next;
+ new_thread->target_data = target_data;
- if (*cur == NULL)
- return;
+ return new_thread;
+}
- (*cur)->next = entry->next;
+/* See gdbthread.h. */
- if (list->tail == entry)
- list->tail = *cur;
+struct thread_info *
+get_first_thread (void)
+{
+ if (!all_threads.empty ())
+ return all_threads.front ();
+ else
+ return NULL;
}
-void
-add_thread (unsigned long thread_id, void *target_data, unsigned int gdb_id)
+struct thread_info *
+find_thread_ptid (ptid_t ptid)
{
- struct thread_info *new_thread = malloc (sizeof (*new_thread));
-
- memset (new_thread, 0, sizeof (*new_thread));
-
- new_thread->entry.id = thread_id;
-
- add_inferior_to_list (&all_threads, & new_thread->entry);
-
- if (current_inferior == NULL)
- current_inferior = new_thread;
-
- new_thread->target_data = target_data;
- set_inferior_regcache_data (new_thread, new_register_cache ());
- new_thread->gdb_id = gdb_id;
+ return find_thread ([&] (thread_info *thread) {
+ return thread->id == ptid;
+ });
}
-unsigned int
-thread_id_to_gdb_id (unsigned long thread_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 (inf->id == thread_id)
- return thread->gdb_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;
+ });
}
-unsigned int
-thread_to_gdb_id (struct thread_info *thread)
+static void
+free_one_thread (thread_info *thread)
{
- return thread->gdb_id;
+ free_register_cache (thread_regcache_data (thread));
+ free (thread);
}
-struct thread_info *
-gdb_id_to_thread (unsigned int gdb_id)
+void
+remove_thread (struct thread_info *thread)
{
- struct inferior_list_entry *inf = all_threads.head;
-
- while (inf != NULL)
- {
- struct thread_info *thread = get_thread (inf);
- if (thread->gdb_id == gdb_id)
- return thread;
- inf = inf->next;
- }
+ if (thread->btrace != NULL)
+ target_disable_btrace (thread->btrace);
- return NULL;
+ discard_queued_stop_replies (ptid_of (thread));
+ all_threads.remove (thread);
+ free_one_thread (thread);
+ if (current_thread == thread)
+ current_thread = NULL;
}
-unsigned long
-gdb_id_to_thread_id (unsigned int gdb_id)
+void *
+thread_target_data (struct thread_info *thread)
{
- struct thread_info *thread = gdb_id_to_thread (gdb_id);
-
- return thread ? thread->entry.id : 0;
+ return thread->target_data;
}
-static void
-free_one_thread (struct inferior_list_entry *inf)
+struct regcache *
+thread_regcache_data (struct thread_info *thread)
{
- struct thread_info *thread = get_thread (inf);
- free_register_cache (inferior_regcache_data (thread));
- free (thread);
+ return thread->regcache_data;
}
void
-remove_thread (struct thread_info *thread)
+set_thread_regcache_data (struct thread_info *thread, struct regcache *data)
{
- remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
- free_one_thread (&thread->entry);
+ thread->regcache_data = data;
}
-struct inferior_list_entry *
-find_inferior (struct inferior_list *list,
- int (*func) (struct inferior_list_entry *, void *), void *arg)
+void
+clear_inferiors (void)
{
- struct inferior_list_entry *inf = list->head;
+ for_each_thread (free_one_thread);
+ all_threads.clear ();
- while (inf != NULL)
- {
- if ((*func) (inf, arg))
- return inf;
- inf = inf->next;
- }
+ clear_dlls ();
- return NULL;
+ current_thread = NULL;
}
-struct inferior_list_entry *
-find_inferior_id (struct inferior_list *list, unsigned long id)
+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 (inf->id == id)
- return inf;
- inf = inf->next;
- }
+ all_processes.push_back (process);
- return NULL;
+ return process;
}
-void *
-inferior_target_data (struct thread_info *inferior)
-{
- return inferior->target_data;
-}
+/* 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
-set_inferior_target_data (struct thread_info *inferior, void *data)
+remove_process (struct process_info *process)
{
- inferior->target_data = data;
+ clear_symbol_cache (&process->symbol_cache);
+ free_all_breakpoints (process);
+ gdb_assert (find_thread_process (process) == NULL);
+ all_processes.remove (process);
+ delete process;
}
-void *
-inferior_regcache_data (struct thread_info *inferior)
+process_info *
+find_process_pid (int pid)
{
- return inferior->regcache_data;
+ return find_process ([&] (process_info *process) {
+ return process->pid == pid;
+ });
}
-void
-set_inferior_regcache_data (struct thread_info *inferior, void *data)
-{
- inferior->regcache_data = data;
-}
+/* Get the first process in the process list, or NULL if the list is empty. */
-static void
-free_one_dll (struct inferior_list_entry *inf)
+process_info *
+get_first_process (void)
{
- struct dll_info *dll = get_dll (inf);
- if (dll->name != NULL)
- free (dll->name);
- free (dll);
+ if (!all_processes.empty ())
+ return all_processes.front ();
+ else
+ return NULL;
}
-/* Find a DLL with the same name and/or base address. A NULL name in
- the key is ignored; so is an all-ones base address. */
+/* Return non-zero if there are any inferiors that we have created
+ (as opposed to attached-to). */
-static int
-match_dll (struct inferior_list_entry *inf, void *arg)
+int
+have_started_inferiors_p (void)
{
- struct dll_info *iter = (void *) inf;
- struct dll_info *key = arg;
-
- if (key->base_addr != ~(CORE_ADDR) 0
- && iter->base_addr == key->base_addr)
- return 1;
- else if (key->name != NULL
- && iter->name != NULL
- && strcmp (key->name, iter->name) == 0)
- return 1;
-
- return 0;
+ return find_process ([] (process_info *process) {
+ return !process->attached;
+ }) != NULL;
}
-/* Record a newly loaded DLL at BASE_ADDR. */
+/* Return non-zero if there are any inferiors that we have attached to. */
-void
-loaded_dll (const char *name, CORE_ADDR base_addr)
+int
+have_attached_inferiors_p (void)
{
- struct dll_info *new_dll = malloc (sizeof (*new_dll));
- memset (new_dll, 0, sizeof (*new_dll));
-
- new_dll->entry.id = -1;
+ return find_process ([] (process_info *process) {
+ return process->attached;
+ }) != NULL;
+}
- new_dll->name = strdup (name);
- new_dll->base_addr = base_addr;
+struct process_info *
+get_thread_process (const struct thread_info *thread)
+{
+ return find_process_pid (thread->id.pid ());
+}
- add_inferior_to_list (&all_dlls, &new_dll->entry);
- dlls_changed = 1;
+struct process_info *
+current_process (void)
+{
+ gdb_assert (current_thread != NULL);
+ return get_thread_process (current_thread);
}
-/* Record that the DLL with NAME and BASE_ADDR has been unloaded. */
+/* See gdbsupport/common-gdbthread.h. */
void
-unloaded_dll (const char *name, CORE_ADDR base_addr)
+switch_to_thread (process_stratum_target *ops, ptid_t ptid)
{
- struct dll_info *dll;
- struct dll_info key_dll;
+ gdb_assert (ptid != minus_one_ptid);
+ current_thread = find_thread_ptid (ptid);
+}
- /* Be careful not to put the key DLL in any list. */
- key_dll.name = (char *) name;
- key_dll.base_addr = base_addr;
+/* See gdbsupport/common-inferior.h. */
- dll = (void *) find_inferior (&all_dlls, match_dll, &key_dll);
- remove_inferior (&all_dlls, &dll->entry);
- free_one_dll (&dll->entry);
- dlls_changed = 1;
+const char *
+get_inferior_cwd ()
+{
+ return current_inferior_cwd;
}
-#define clear_list(LIST) \
- do { (LIST)->head = (LIST)->tail = NULL; } while (0)
+/* See gdbsupport/common-inferior.h. */
void
-clear_inferiors (void)
+set_inferior_cwd (const char *cwd)
{
- for_each_inferior (&all_threads, free_one_thread);
- for_each_inferior (&all_dlls, free_one_dll);
-
- clear_list (&all_threads);
- clear_list (&all_dlls);
+ xfree ((void *) current_inferior_cwd);
+ if (cwd != NULL)
+ current_inferior_cwd = xstrdup (cwd);
+ else
+ current_inferior_cwd = NULL;
}
projects / deliverable / binutils-gdb.git / blobdiff