/* Target operations for the remote server for GDB.
- Copyright (C) 2002-2013 Free Software Foundation, Inc.
+ Copyright (C) 2002-2016 Free Software Foundation, Inc.
Contributed by MontaVista Software.
struct target_ops *the_target;
-void
-set_desired_inferior (int use_general)
+int
+set_desired_thread (int use_general)
{
struct thread_info *found;
else
found = find_thread_ptid (cont_thread);
- if (found == NULL)
- current_inferior = (struct thread_info *) all_threads.head;
+ current_thread = found;
+ return (current_thread != NULL);
+}
+
+/* Structure used to look up a thread to use as current when accessing
+ memory. */
+
+struct thread_search
+{
+ /* The PTID of the current general thread. This is an input
+ parameter. */
+ ptid_t current_gen_ptid;
+
+ /* The first thread found. */
+ struct thread_info *first;
+
+ /* The first stopped thread found. */
+ struct thread_info *stopped;
+
+ /* The current general thread, if found. */
+ struct thread_info *current;
+};
+
+/* Callback for find_inferior. Search for a thread to use as current
+ when accessing memory. */
+
+static int
+thread_search_callback (struct inferior_list_entry *entry, void *args)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct thread_search *s = (struct thread_search *) args;
+
+ if (ptid_get_pid (entry->id) == ptid_get_pid (s->current_gen_ptid)
+ && mythread_alive (ptid_of (thread)))
+ {
+ if (s->stopped == NULL
+ && the_target->thread_stopped != NULL
+ && thread_stopped (thread))
+ s->stopped = thread;
+
+ if (s->first == NULL)
+ s->first = thread;
+
+ if (s->current == NULL && ptid_equal (s->current_gen_ptid, entry->id))
+ s->current = thread;
+ }
+
+ return 0;
+}
+
+/* The thread that was current before prepare_to_access_memory was
+ called. done_accessing_memory uses this to restore the previous
+ selected thread. */
+static ptid_t prev_general_thread;
+
+/* See target.h. */
+
+int
+prepare_to_access_memory (void)
+{
+ struct thread_search search;
+ struct thread_info *thread;
+
+ memset (&search, 0, sizeof (search));
+ search.current_gen_ptid = general_thread;
+ prev_general_thread = general_thread;
+
+ if (the_target->prepare_to_access_memory != NULL)
+ {
+ int res;
+
+ res = the_target->prepare_to_access_memory ();
+ if (res != 0)
+ return res;
+ }
+
+ find_inferior (&all_threads, thread_search_callback, &search);
+
+ /* Prefer a stopped thread. If none is found, try the current
+ thread. Otherwise, take the first thread in the process. If
+ none is found, undo the effects of
+ target->prepare_to_access_memory() and return error. */
+ if (search.stopped != NULL)
+ thread = search.stopped;
+ else if (search.current != NULL)
+ thread = search.current;
+ else if (search.first != NULL)
+ thread = search.first;
else
- current_inferior = found;
+ {
+ done_accessing_memory ();
+ return 1;
+ }
+
+ current_thread = thread;
+ general_thread = ptid_of (thread);
+
+ return 0;
+}
+
+/* See target.h. */
+
+void
+done_accessing_memory (void)
+{
+ if (the_target->done_accessing_memory != NULL)
+ the_target->done_accessing_memory ();
+
+ /* Restore the previous selected thread. */
+ general_thread = prev_general_thread;
+ current_thread = find_thread_ptid (general_thread);
}
int
return res;
}
+/* See target/target.h. */
+
+int
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
+{
+ return read_inferior_memory (memaddr, myaddr, len);
+}
+
+/* See target/target.h. */
+
+int
+target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
+{
+ return read_inferior_memory (memaddr, (gdb_byte *) result, sizeof (*result));
+}
+
int
write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
int len)
if (buffer != NULL)
free (buffer);
- buffer = xmalloc (len);
+ buffer = (unsigned char *) xmalloc (len);
memcpy (buffer, myaddr, len);
check_mem_write (memaddr, buffer, myaddr, len);
res = (*the_target->write_memory) (memaddr, buffer, len);
return res;
}
+/* See target/target.h. */
+
+int
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
+{
+ return write_inferior_memory (memaddr, myaddr, len);
+}
+
ptid_t
mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options,
int connected_wait)
return ret;
}
+/* See target/target.h. */
+
+void
+target_stop_and_wait (ptid_t ptid)
+{
+ struct target_waitstatus status;
+ int was_non_stop = non_stop;
+ struct thread_resume resume_info;
+
+ resume_info.thread = ptid;
+ resume_info.kind = resume_stop;
+ resume_info.sig = GDB_SIGNAL_0;
+ (*the_target->resume) (&resume_info, 1);
+
+ non_stop = 1;
+ mywait (ptid, &status, 0, 0);
+ non_stop = was_non_stop;
+}
+
+/* See target/target.h. */
+
+void
+target_continue_no_signal (ptid_t ptid)
+{
+ struct thread_resume resume_info;
+
+ resume_info.thread = ptid;
+ resume_info.kind = resume_continue;
+ resume_info.sig = GDB_SIGNAL_0;
+ (*the_target->resume) (&resume_info, 1);
+}
+
int
start_non_stop (int nonstop)
{
void
set_target_ops (struct target_ops *target)
{
- the_target = (struct target_ops *) xmalloc (sizeof (*the_target));
+ the_target = XNEW (struct target_ops);
memcpy (the_target, target, sizeof (*the_target));
}
return (*the_target->kill) (pid);
}
+
+/* Target can do hardware single step. */
+
+int
+target_can_do_hardware_single_step (void)
+{
+ return 1;
+}
+
+/* Default implementation for breakpoint_kind_for_pc.
+
+ The default behavior for targets that don't implement breakpoint_kind_for_pc
+ is to use the size of a breakpoint as the kind. */
+
+int
+default_breakpoint_kind_from_pc (CORE_ADDR *pcptr)
+{
+ int size = 0;
+
+ gdb_assert (the_target->sw_breakpoint_from_kind != NULL);
+
+ (*the_target->sw_breakpoint_from_kind) (0, &size);
+ return size;
+}
projects / deliverable / binutils-gdb.git / blobdiff