/* Inferior process information for the remote server for GDB.
- Copyright 2002
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2015 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 inferior_list all_processes;
+struct inferior_list all_threads;
+
+struct thread_info *current_thread;
+
+#define get_thread(inf) ((struct thread_info *)(inf))
+
+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;
+}
+
+/* Invoke ACTION for each inferior in LIST. */
+
+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;
+ }
+}
+
+/* Invoke ACTION for each inferior in LIST, passing DATA to ACTION. */
-struct inferior_info
+void
+for_each_inferior_with_data (struct inferior_list *list,
+ void (*action) (struct inferior_list_entry *,
+ void *),
+ void *data)
{
- int pid;
- void *target_data;
- void *regcache_data;
- struct inferior_info *next;
-};
+ struct inferior_list_entry *cur = list->head, *next;
-static struct inferior_info *inferiors;
-struct inferior_info *current_inferior;
-int signal_pid;
+ while (cur != NULL)
+ {
+ next = cur->next;
+ (*action) (cur, data);
+ cur = next;
+ }
+}
void
-add_inferior (int pid)
+remove_inferior (struct inferior_list *list,
+ struct inferior_list_entry *entry)
+{
+ 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;
+
+ (*cur)->next = entry->next;
+
+ if (list->tail == entry)
+ list->tail = *cur;
+}
+
+struct thread_info *
+add_thread (ptid_t thread_id, void *target_data)
{
- struct inferior_info *new_inferior
- = (struct inferior_info *) malloc (sizeof (*new_inferior));
+ struct thread_info *new_thread = xmalloc (sizeof (*new_thread));
+
+ memset (new_thread, 0, sizeof (*new_thread));
+
+ new_thread->entry.id = thread_id;
+ new_thread->last_resume_kind = resume_continue;
+ new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
+
+ add_inferior_to_list (&all_threads, &new_thread->entry);
- memset (new_inferior, 0, sizeof (*new_inferior));
+ if (current_thread == NULL)
+ current_thread = new_thread;
- new_inferior->pid = pid;
+ new_thread->target_data = target_data;
- new_inferior->next = inferiors;
- inferiors = new_inferior;
+ return new_thread;
+}
+
+ptid_t
+thread_to_gdb_id (struct thread_info *thread)
+{
+ return thread->entry.id;
+}
+
+/* Wrapper around get_first_inferior to return a struct thread_info *. */
+
+struct thread_info *
+get_first_thread (void)
+{
+ return (struct thread_info *) get_first_inferior (&all_threads);
+}
+
+struct thread_info *
+find_thread_ptid (ptid_t ptid)
+{
+ return (struct thread_info *) find_inferior_id (&all_threads, ptid);
+}
- if (current_inferior == NULL)
- current_inferior = inferiors;
+ptid_t
+gdb_id_to_thread_id (ptid_t gdb_id)
+{
+ struct thread_info *thread = find_thread_ptid (gdb_id);
- create_register_cache (new_inferior);
+ return thread ? thread->entry.id : null_ptid;
+}
- if (signal_pid == 0)
- signal_pid = pid;
+static void
+free_one_thread (struct inferior_list_entry *inf)
+{
+ struct thread_info *thread = get_thread (inf);
+ free_register_cache (inferior_regcache_data (thread));
+ free (thread);
}
void
-clear_inferiors (void)
+remove_thread (struct thread_info *thread)
{
- struct inferior_info *inf = inferiors, *next_inf;
+ if (thread->btrace != NULL)
+ target_disable_btrace (thread->btrace);
- while (inf)
+ remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
+ free_one_thread (&thread->entry);
+}
+
+/* Return a pointer to the first inferior in LIST, or NULL if there isn't one.
+ This is for cases where the caller needs a thread, but doesn't care
+ which one. */
+
+struct inferior_list_entry *
+get_first_inferior (struct inferior_list *list)
+{
+ if (list->head != NULL)
+ return list->head;
+ return NULL;
+}
+
+/* Find the first inferior_list_entry E in LIST for which FUNC (E, ARG)
+ returns non-zero. If no entry is found then return NULL. */
+
+struct inferior_list_entry *
+find_inferior (struct inferior_list *list,
+ int (*func) (struct inferior_list_entry *, void *), void *arg)
+{
+ struct inferior_list_entry *inf = list->head;
+
+ while (inf != NULL)
{
- next_inf = inf->next;
+ struct inferior_list_entry *next;
+
+ next = inf->next;
+ if ((*func) (inf, arg))
+ return inf;
+ inf = next;
+ }
- if (inf->target_data)
- free (inf->target_data);
- if (inf->regcache_data)
- free_register_cache (inf);
+ return NULL;
+}
+
+struct inferior_list_entry *
+find_inferior_id (struct inferior_list *list, ptid_t id)
+{
+ struct inferior_list_entry *inf = list->head;
- free (inf);
- inf = next_inf;
+ while (inf != NULL)
+ {
+ if (ptid_equal (inf->id, id))
+ return inf;
+ inf = inf->next;
}
- inferiors = NULL;
+ return NULL;
}
void *
-inferior_target_data (struct inferior_info *inferior)
+inferior_target_data (struct thread_info *inferior)
{
return inferior->target_data;
}
void
-set_inferior_target_data (struct inferior_info *inferior, void *data)
+set_inferior_target_data (struct thread_info *inferior, void *data)
{
inferior->target_data = data;
}
-void *
-inferior_regcache_data (struct inferior_info *inferior)
+struct regcache *
+inferior_regcache_data (struct thread_info *inferior)
{
return inferior->regcache_data;
}
void
-set_inferior_regcache_data (struct inferior_info *inferior, void *data)
+set_inferior_regcache_data (struct thread_info *inferior, struct regcache *data)
{
inferior->regcache_data = data;
}
+
+/* Return true if LIST has exactly one entry. */
+
+int
+one_inferior_p (struct inferior_list *list)
+{
+ return list->head != NULL && list->head == list->tail;
+}
+
+/* Reset head,tail of LIST, assuming all entries have already been freed. */
+
+void
+clear_inferior_list (struct inferior_list *list)
+{
+ list->head = NULL;
+ list->tail = NULL;
+}
+
+void
+clear_inferiors (void)
+{
+ for_each_inferior (&all_threads, free_one_thread);
+ clear_inferior_list (&all_threads);
+
+ clear_dlls ();
+
+ current_thread = NULL;
+}
+
+struct process_info *
+add_process (int pid, int attached)
+{
+ struct process_info *process;
+
+ process = xcalloc (1, sizeof (*process));
+
+ process->entry.id = pid_to_ptid (pid);
+ process->attached = attached;
+
+ add_inferior_to_list (&all_processes, &process->entry);
+
+ 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_process (struct process_info *process)
+{
+ clear_symbol_cache (&process->symbol_cache);
+ free_all_breakpoints (process);
+ remove_inferior (&all_processes, &process->entry);
+ free (process);
+}
+
+struct process_info *
+find_process_pid (int pid)
+{
+ return (struct process_info *)
+ find_inferior_id (&all_processes, pid_to_ptid (pid));
+}
+
+/* Return non-zero if INF, a struct process_info, was started by us,
+ i.e. not attached to. */
+
+static int
+started_inferior_callback (struct inferior_list_entry *entry, void *args)
+{
+ struct process_info *process = (struct process_info *) entry;
+
+ return ! process->attached;
+}
+
+/* Return non-zero if there are any inferiors that we have created
+ (as opposed to attached-to). */
+
+int
+have_started_inferiors_p (void)
+{
+ return (find_inferior (&all_processes, started_inferior_callback, NULL)
+ != NULL);
+}
+
+/* Return non-zero if INF, a struct process_info, was attached to. */
+
+static int
+attached_inferior_callback (struct inferior_list_entry *entry, void *args)
+{
+ struct process_info *process = (struct process_info *) entry;
+
+ return process->attached;
+}
+
+/* Return non-zero if there are any inferiors that we have attached to. */
+
+int
+have_attached_inferiors_p (void)
+{
+ return (find_inferior (&all_processes, attached_inferior_callback, NULL)
+ != NULL);
+}
+
+struct process_info *
+get_thread_process (struct thread_info *thread)
+{
+ int pid = ptid_get_pid (thread->entry.id);
+ return find_process_pid (pid);
+}
+
+struct process_info *
+current_process (void)
+{
+ gdb_assert (current_thread != NULL);
+ return get_thread_process (current_thread);
+}
projects / deliverable / binutils-gdb.git / blobdiff