/* Register support routines for the remote server for GDB.
- Copyright 2001, 2002
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2018 Free Software Foundation, Inc.
This file is part of GDB.
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. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "server.h"
#include "regdef.h"
+#include "gdbthread.h"
+#include "tdesc.h"
+#include "rsp-low.h"
+#ifndef IN_PROCESS_AGENT
-#include <stdlib.h>
-#include <string.h>
-
-struct inferior_regcache_data
+struct regcache *
+get_thread_regcache (struct thread_info *thread, int fetch)
{
- int registers_valid;
- char *registers;
-};
+ struct regcache *regcache;
-static int register_bytes;
+ /* Check the target descriptor is still valid for the current target. If
+ not, then clear it and create a new one. */
+ if (!target_validate_tdesc (thread))
+ {
+ /* Clear regcache. */
+ free_register_cache (thread_regcache_data (thread));
+ set_thread_regcache_data (thread, NULL);
+ regcache = NULL;
-static struct reg *reg_defs;
-static int num_registers;
+ target_arch_setup ();
+ }
-const char **gdbserver_expedite_regs;
+ regcache = thread_regcache_data (thread);
-static struct inferior_regcache_data *
-get_regcache (struct thread_info *inf, int fetch)
-{
- struct inferior_regcache_data *regcache;
+ /* Threads' regcaches are created lazily, because biarch targets add
+ the main thread/lwp before seeing it stop for the first time, and
+ it is only after the target sees the thread stop for the first
+ time that the target has a chance of determining the process's
+ architecture. IOW, when we first add the process's main thread
+ we don't know which architecture/tdesc its regcache should
+ have. */
+ if (regcache == NULL)
+ {
+ struct process_info *proc = get_thread_process (thread);
- regcache = (struct inferior_regcache_data *) inferior_regcache_data (inf);
+ gdb_assert (proc->tdesc != NULL);
- if (regcache == NULL)
- fatal ("no register cache");
+ regcache = new_register_cache (proc->tdesc);
+ set_thread_regcache_data (thread, regcache);
+ }
- /* FIXME - fetch registers for INF */
if (fetch && regcache->registers_valid == 0)
{
- fetch_inferior_registers (0);
+ struct thread_info *saved_thread = current_thread;
+
+ current_thread = thread;
+ /* Invalidate all registers, to prevent stale left-overs. */
+ memset (regcache->register_status, REG_UNAVAILABLE,
+ regcache->tdesc->reg_defs.size ());
+ fetch_inferior_registers (regcache, -1);
+ current_thread = saved_thread;
regcache->registers_valid = 1;
}
return regcache;
}
+/* See common/common-regcache.h. */
+
+struct regcache *
+get_thread_regcache_for_ptid (ptid_t ptid)
+{
+ return get_thread_regcache (find_thread_ptid (ptid), 1);
+}
+
void
-regcache_invalidate_one (struct inferior_list_entry *entry)
+regcache_invalidate_thread (struct thread_info *thread)
{
- struct thread_info *thread = (struct thread_info *) entry;
- struct inferior_regcache_data *regcache;
+ struct regcache *regcache;
+
+ regcache = thread_regcache_data (thread);
- regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
+ if (regcache == NULL)
+ return;
if (regcache->registers_valid)
{
- struct thread_info *saved_inferior = current_inferior;
+ struct thread_info *saved_thread = current_thread;
- current_inferior = thread;
- store_inferior_registers (-1);
- current_inferior = saved_inferior;
+ current_thread = thread;
+ store_inferior_registers (regcache, -1);
+ current_thread = saved_thread;
}
regcache->registers_valid = 0;
}
+/* See regcache.h. */
+
void
-regcache_invalidate ()
+regcache_invalidate_pid (int pid)
{
- for_each_inferior (&all_threads, regcache_invalidate_one);
+ /* Only invalidate the regcaches of threads of this process. */
+ for_each_thread (pid, regcache_invalidate_thread);
}
-int
-registers_length (void)
-{
- return 2 * register_bytes;
-}
+/* See regcache.h. */
-void *
-new_register_cache (void)
+void
+regcache_invalidate (void)
{
- struct inferior_regcache_data *regcache;
+ /* Only update the threads of the current process. */
+ int pid = current_thread->id.pid ();
+
+ regcache_invalidate_pid (pid);
+}
- regcache = malloc (sizeof (*regcache));
+#endif
- regcache->registers = malloc (register_bytes);
- if (regcache->registers == NULL)
- fatal ("Could not allocate register cache.");
+struct regcache *
+init_register_cache (struct regcache *regcache,
+ const struct target_desc *tdesc,
+ unsigned char *regbuf)
+{
+ if (regbuf == NULL)
+ {
+#ifndef IN_PROCESS_AGENT
+ /* Make sure to zero-initialize the register cache when it is
+ created, in case there are registers the target never
+ fetches. This way they'll read as zero instead of
+ garbage. */
+ regcache->tdesc = tdesc;
+ regcache->registers
+ = (unsigned char *) xcalloc (1, tdesc->registers_size);
+ regcache->registers_owned = 1;
+ regcache->register_status
+ = (unsigned char *) xmalloc (tdesc->reg_defs.size ());
+ memset ((void *) regcache->register_status, REG_UNAVAILABLE,
+ tdesc->reg_defs.size ());
+#else
+ gdb_assert_not_reached ("can't allocate memory from the heap");
+#endif
+ }
+ else
+ {
+ regcache->tdesc = tdesc;
+ regcache->registers = regbuf;
+ regcache->registers_owned = 0;
+#ifndef IN_PROCESS_AGENT
+ regcache->register_status = NULL;
+#endif
+ }
regcache->registers_valid = 0;
return regcache;
}
-void
-free_register_cache (void *regcache_p)
+#ifndef IN_PROCESS_AGENT
+
+struct regcache *
+new_register_cache (const struct target_desc *tdesc)
{
- struct inferior_regcache_data *regcache
- = (struct inferior_regcache_data *) regcache_p;
+ struct regcache *regcache = new struct regcache;
+
+ gdb_assert (tdesc->registers_size != 0);
- free (regcache->registers);
- free (regcache);
+ return init_register_cache (regcache, tdesc, NULL);
}
void
-set_register_cache (struct reg *regs, int n)
+free_register_cache (struct regcache *regcache)
{
- int offset, i;
-
- reg_defs = regs;
- num_registers = n;
-
- offset = 0;
- for (i = 0; i < n; i++)
+ if (regcache)
{
- regs[i].offset = offset;
- offset += regs[i].size;
+ if (regcache->registers_owned)
+ free (regcache->registers);
+ free (regcache->register_status);
+ delete regcache;
}
+}
- register_bytes = offset / 8;
+#endif
+
+void
+regcache_cpy (struct regcache *dst, struct regcache *src)
+{
+ gdb_assert (src != NULL && dst != NULL);
+ gdb_assert (src->tdesc == dst->tdesc);
+ gdb_assert (src != dst);
+
+ memcpy (dst->registers, src->registers, src->tdesc->registers_size);
+#ifndef IN_PROCESS_AGENT
+ if (dst->register_status != NULL && src->register_status != NULL)
+ memcpy (dst->register_status, src->register_status,
+ src->tdesc->reg_defs.size ());
+#endif
+ dst->registers_valid = src->registers_valid;
+}
+
+/* Return a reference to the description of register N. */
+
+static const struct reg &
+find_register_by_number (const struct target_desc *tdesc, int n)
+{
+ return tdesc->reg_defs[n];
}
+#ifndef IN_PROCESS_AGENT
+
void
-registers_to_string (char *buf)
+registers_to_string (struct regcache *regcache, char *buf)
{
- char *registers = get_regcache (current_inferior, 1)->registers;
+ unsigned char *registers = regcache->registers;
+ const struct target_desc *tdesc = regcache->tdesc;
- convert_int_to_ascii (registers, buf, register_bytes);
+ for (int i = 0; i < tdesc->reg_defs.size (); ++i)
+ {
+ if (regcache->register_status[i] == REG_VALID)
+ {
+ bin2hex (registers, buf, register_size (tdesc, i));
+ buf += register_size (tdesc, i) * 2;
+ }
+ else
+ {
+ memset (buf, 'x', register_size (tdesc, i) * 2);
+ buf += register_size (tdesc, i) * 2;
+ }
+ registers += register_size (tdesc, i);
+ }
+ *buf = '\0';
}
void
-registers_from_string (char *buf)
+registers_from_string (struct regcache *regcache, char *buf)
{
int len = strlen (buf);
- char *registers = get_regcache (current_inferior, 1)->registers;
+ unsigned char *registers = regcache->registers;
+ const struct target_desc *tdesc = regcache->tdesc;
+
+ if (len != tdesc->registers_size * 2)
+ {
+ warning ("Wrong sized register packet (expected %d bytes, got %d)",
+ 2 * tdesc->registers_size, len);
+ if (len > tdesc->registers_size * 2)
+ len = tdesc->registers_size * 2;
+ }
+ hex2bin (buf, registers, len / 2);
+}
+
+int
+find_regno (const struct target_desc *tdesc, const char *name)
+{
+ for (int i = 0; i < tdesc->reg_defs.size (); ++i)
+ {
+ if (strcmp (name, find_register_by_number (tdesc, i).name) == 0)
+ return i;
+ }
+ internal_error (__FILE__, __LINE__, "Unknown register %s requested",
+ name);
+}
+
+static void
+free_register_cache_thread (struct thread_info *thread)
+{
+ struct regcache *regcache = thread_regcache_data (thread);
- if (len != register_bytes * 2)
+ if (regcache != NULL)
{
- warning ("Wrong sized register packet (expected %d bytes, got %d)", 2*register_bytes, len);
- if (len > register_bytes * 2)
- len = register_bytes * 2;
+ regcache_invalidate_thread (thread);
+ free_register_cache (regcache);
+ set_thread_regcache_data (thread, NULL);
}
- convert_ascii_to_int (buf, registers, len / 2);
}
-struct reg *
-find_register_by_name (const char *name)
+void
+regcache_release (void)
{
- int i;
+ /* Flush and release all pre-existing register caches. */
+ for_each_thread (free_register_cache_thread);
+}
+#endif
- for (i = 0; i < num_registers; i++)
- if (!strcmp (name, reg_defs[i].name))
- return ®_defs[i];
- fatal ("Unknown register %s requested", name);
- return 0;
+int
+register_cache_size (const struct target_desc *tdesc)
+{
+ return tdesc->registers_size;
}
int
-find_regno (const char *name)
+register_size (const struct target_desc *tdesc, int n)
{
- int i;
+ return find_register_by_number (tdesc, n).size / 8;
+}
+
+/* See common/common-regcache.h. */
- for (i = 0; i < num_registers; i++)
- if (!strcmp (name, reg_defs[i].name))
- return i;
- fatal ("Unknown register %s requested", name);
- return -1;
+int
+regcache_register_size (const struct regcache *regcache, int n)
+{
+ return register_size (regcache->tdesc, n);
}
-struct reg *
-find_register_by_number (int n)
+static unsigned char *
+register_data (const struct regcache *regcache, int n, int fetch)
{
- return ®_defs[n];
+ return (regcache->registers
+ + find_register_by_number (regcache->tdesc, n).offset / 8);
}
-int
-register_size (int n)
+void
+supply_register (struct regcache *regcache, int n, const void *buf)
+{
+ return regcache->raw_supply (n, buf);
+}
+
+/* See common/common-regcache.h. */
+
+void
+regcache::raw_supply (int n, const void *buf)
{
- return reg_defs[n].size / 8;
+ if (buf)
+ {
+ memcpy (register_data (this, n, 0), buf, register_size (tdesc, n));
+#ifndef IN_PROCESS_AGENT
+ if (register_status != NULL)
+ register_status[n] = REG_VALID;
+#endif
+ }
+ else
+ {
+ memset (register_data (this, n, 0), 0, register_size (tdesc, n));
+#ifndef IN_PROCESS_AGENT
+ if (register_status != NULL)
+ register_status[n] = REG_UNAVAILABLE;
+#endif
+ }
}
-static char *
-register_data (int n, int fetch)
+/* Supply register N with value zero to REGCACHE. */
+
+void
+supply_register_zeroed (struct regcache *regcache, int n)
{
- char *registers = get_regcache (current_inferior, fetch)->registers;
+ memset (register_data (regcache, n, 0), 0,
+ register_size (regcache->tdesc, n));
+#ifndef IN_PROCESS_AGENT
+ if (regcache->register_status != NULL)
+ regcache->register_status[n] = REG_VALID;
+#endif
+}
+
+#ifndef IN_PROCESS_AGENT
- return registers + (reg_defs[n].offset / 8);
+/* Supply register called NAME with value zero to REGCACHE. */
+
+void
+supply_register_by_name_zeroed (struct regcache *regcache,
+ const char *name)
+{
+ supply_register_zeroed (regcache, find_regno (regcache->tdesc, name));
}
+#endif
+
+/* Supply the whole register set whose contents are stored in BUF, to
+ REGCACHE. If BUF is NULL, all the registers' values are recorded
+ as unavailable. */
+
void
-supply_register (int n, const void *buf)
+supply_regblock (struct regcache *regcache, const void *buf)
{
- memcpy (register_data (n, 0), buf, register_size (n));
+ if (buf)
+ {
+ const struct target_desc *tdesc = regcache->tdesc;
+
+ memcpy (regcache->registers, buf, tdesc->registers_size);
+#ifndef IN_PROCESS_AGENT
+ {
+ int i;
+
+ for (i = 0; i < tdesc->reg_defs.size (); i++)
+ regcache->register_status[i] = REG_VALID;
+ }
+#endif
+ }
+ else
+ {
+ const struct target_desc *tdesc = regcache->tdesc;
+
+ memset (regcache->registers, 0, tdesc->registers_size);
+#ifndef IN_PROCESS_AGENT
+ {
+ int i;
+
+ for (i = 0; i < tdesc->reg_defs.size (); i++)
+ regcache->register_status[i] = REG_UNAVAILABLE;
+ }
+#endif
+ }
}
+#ifndef IN_PROCESS_AGENT
+
void
-supply_register_by_name (const char *name, const void *buf)
+supply_register_by_name (struct regcache *regcache,
+ const char *name, const void *buf)
{
- supply_register (find_regno (name), buf);
+ supply_register (regcache, find_regno (regcache->tdesc, name), buf);
}
+#endif
+
void
-collect_register (int n, void *buf)
+collect_register (struct regcache *regcache, int n, void *buf)
{
- memcpy (buf, register_data (n, 1), register_size (n));
+ regcache->raw_collect (n, buf);
}
+/* See common/common-regcache.h. */
+
void
-collect_register_as_string (int n, char *buf)
+regcache::raw_collect (int n, void *buf) const
{
- convert_int_to_ascii (register_data (n, 1), buf, register_size (n));
+ memcpy (buf, register_data (this, n, 1), register_size (tdesc, n));
+}
+
+enum register_status
+regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
+ ULONGEST *val)
+{
+ int size;
+
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0
+ && regnum < regcache->tdesc->reg_defs.size ());
+
+ size = register_size (regcache->tdesc, regnum);
+
+ if (size > (int) sizeof (ULONGEST))
+ error (_("That operation is not available on integers of more than"
+ "%d bytes."),
+ (int) sizeof (ULONGEST));
+
+ *val = 0;
+ collect_register (regcache, regnum, val);
+
+ return REG_VALID;
+}
+
+#ifndef IN_PROCESS_AGENT
+
+/* See regcache.h. */
+
+ULONGEST
+regcache_raw_get_unsigned_by_name (struct regcache *regcache,
+ const char *name)
+{
+ return regcache_raw_get_unsigned (regcache,
+ find_regno (regcache->tdesc, name));
+}
+
+void
+collect_register_as_string (struct regcache *regcache, int n, char *buf)
+{
+ bin2hex (register_data (regcache, n, 1), buf,
+ register_size (regcache->tdesc, n));
+}
+
+void
+collect_register_by_name (struct regcache *regcache,
+ const char *name, void *buf)
+{
+ collect_register (regcache, find_regno (regcache->tdesc, name), buf);
+}
+
+/* Special handling for register PC. */
+
+CORE_ADDR
+regcache_read_pc (struct regcache *regcache)
+{
+ CORE_ADDR pc_val;
+
+ if (the_target->read_pc)
+ pc_val = the_target->read_pc (regcache);
+ else
+ internal_error (__FILE__, __LINE__,
+ "regcache_read_pc: Unable to find PC");
+
+ return pc_val;
}
void
-collect_register_by_name (const char *name, void *buf)
+regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
+{
+ if (the_target->write_pc)
+ the_target->write_pc (regcache, pc);
+ else
+ internal_error (__FILE__, __LINE__,
+ "regcache_write_pc: Unable to update PC");
+}
+
+#endif
+
+/* See common/common-regcache.h. */
+
+enum register_status
+regcache::get_register_status (int regnum) const
+{
+#ifndef IN_PROCESS_AGENT
+ gdb_assert (regnum >= 0 && regnum < tdesc->reg_defs.size ());
+ return (enum register_status) (register_status[regnum]);
+#else
+ return REG_VALID;
+#endif
+}
+
+/* See common/common-regcache.h. */
+
+bool
+regcache::raw_compare (int regnum, const void *buf, int offset) const
{
- collect_register (find_regno (name), buf);
+ gdb_assert (buf != NULL);
+
+ const unsigned char *regbuf = register_data (this, regnum, 1);
+ int size = register_size (tdesc, regnum);
+ gdb_assert (size >= offset);
+
+ return (memcmp (buf, regbuf + offset, size - offset) == 0);
}
projects / thirdparty / binutils-gdb.git / blobdiff