/* Register support routines for the remote server for GDB.
|
/* Register support routines for the remote server for GDB.
|
Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008
|
Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "server.h"
|
#include "server.h"
|
#include "regdef.h"
|
#include "regdef.h"
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <string.h>
|
|
|
/* The private data for the register cache. Note that we have one
|
/* The private data for the register cache. Note that we have one
|
per inferior; this is primarily for simplicity, as the performance
|
per inferior; this is primarily for simplicity, as the performance
|
benefit is minimal. */
|
benefit is minimal. */
|
|
|
struct inferior_regcache_data
|
struct inferior_regcache_data
|
{
|
{
|
int registers_valid;
|
int registers_valid;
|
unsigned char *registers;
|
unsigned char *registers;
|
};
|
};
|
|
|
static int register_bytes;
|
static int register_bytes;
|
|
|
static struct reg *reg_defs;
|
static struct reg *reg_defs;
|
static int num_registers;
|
static int num_registers;
|
|
|
const char **gdbserver_expedite_regs;
|
const char **gdbserver_expedite_regs;
|
|
|
static struct inferior_regcache_data *
|
static struct inferior_regcache_data *
|
get_regcache (struct thread_info *inf, int fetch)
|
get_regcache (struct thread_info *inf, int fetch)
|
{
|
{
|
struct inferior_regcache_data *regcache;
|
struct inferior_regcache_data *regcache;
|
|
|
regcache = (struct inferior_regcache_data *) inferior_regcache_data (inf);
|
regcache = (struct inferior_regcache_data *) inferior_regcache_data (inf);
|
|
|
if (regcache == NULL)
|
if (regcache == NULL)
|
fatal ("no register cache");
|
fatal ("no register cache");
|
|
|
/* FIXME - fetch registers for INF */
|
/* FIXME - fetch registers for INF */
|
if (fetch && regcache->registers_valid == 0)
|
if (fetch && regcache->registers_valid == 0)
|
{
|
{
|
fetch_inferior_registers (0);
|
fetch_inferior_registers (0);
|
regcache->registers_valid = 1;
|
regcache->registers_valid = 1;
|
}
|
}
|
|
|
return regcache;
|
return regcache;
|
}
|
}
|
|
|
void
|
void
|
regcache_invalidate_one (struct inferior_list_entry *entry)
|
regcache_invalidate_one (struct inferior_list_entry *entry)
|
{
|
{
|
struct thread_info *thread = (struct thread_info *) entry;
|
struct thread_info *thread = (struct thread_info *) entry;
|
struct inferior_regcache_data *regcache;
|
struct inferior_regcache_data *regcache;
|
|
|
regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
|
regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
|
|
|
if (regcache->registers_valid)
|
if (regcache->registers_valid)
|
{
|
{
|
struct thread_info *saved_inferior = current_inferior;
|
struct thread_info *saved_inferior = current_inferior;
|
|
|
current_inferior = thread;
|
current_inferior = thread;
|
store_inferior_registers (-1);
|
store_inferior_registers (-1);
|
current_inferior = saved_inferior;
|
current_inferior = saved_inferior;
|
}
|
}
|
|
|
regcache->registers_valid = 0;
|
regcache->registers_valid = 0;
|
}
|
}
|
|
|
void
|
void
|
regcache_invalidate ()
|
regcache_invalidate ()
|
{
|
{
|
for_each_inferior (&all_threads, regcache_invalidate_one);
|
for_each_inferior (&all_threads, regcache_invalidate_one);
|
}
|
}
|
|
|
int
|
int
|
registers_length (void)
|
registers_length (void)
|
{
|
{
|
return 2 * register_bytes;
|
return 2 * register_bytes;
|
}
|
}
|
|
|
void *
|
void *
|
new_register_cache (void)
|
new_register_cache (void)
|
{
|
{
|
struct inferior_regcache_data *regcache;
|
struct inferior_regcache_data *regcache;
|
|
|
regcache = malloc (sizeof (*regcache));
|
regcache = malloc (sizeof (*regcache));
|
|
|
/* Make sure to zero-initialize the register cache when it is created,
|
/* 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
|
in case there are registers the target never fetches. This way they'll
|
read as zero instead of garbage. */
|
read as zero instead of garbage. */
|
regcache->registers = calloc (1, register_bytes);
|
regcache->registers = calloc (1, register_bytes);
|
if (regcache->registers == NULL)
|
if (regcache->registers == NULL)
|
fatal ("Could not allocate register cache.");
|
fatal ("Could not allocate register cache.");
|
|
|
regcache->registers_valid = 0;
|
regcache->registers_valid = 0;
|
|
|
return regcache;
|
return regcache;
|
}
|
}
|
|
|
void
|
void
|
free_register_cache (void *regcache_p)
|
free_register_cache (void *regcache_p)
|
{
|
{
|
struct inferior_regcache_data *regcache
|
struct inferior_regcache_data *regcache
|
= (struct inferior_regcache_data *) regcache_p;
|
= (struct inferior_regcache_data *) regcache_p;
|
|
|
free (regcache->registers);
|
free (regcache->registers);
|
free (regcache);
|
free (regcache);
|
}
|
}
|
|
|
void
|
void
|
set_register_cache (struct reg *regs, int n)
|
set_register_cache (struct reg *regs, int n)
|
{
|
{
|
int offset, i;
|
int offset, i;
|
|
|
reg_defs = regs;
|
reg_defs = regs;
|
num_registers = n;
|
num_registers = n;
|
|
|
offset = 0;
|
offset = 0;
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
{
|
{
|
regs[i].offset = offset;
|
regs[i].offset = offset;
|
offset += regs[i].size;
|
offset += regs[i].size;
|
}
|
}
|
|
|
register_bytes = offset / 8;
|
register_bytes = offset / 8;
|
}
|
}
|
|
|
void
|
void
|
registers_to_string (char *buf)
|
registers_to_string (char *buf)
|
{
|
{
|
unsigned char *registers = get_regcache (current_inferior, 1)->registers;
|
unsigned char *registers = get_regcache (current_inferior, 1)->registers;
|
|
|
convert_int_to_ascii (registers, buf, register_bytes);
|
convert_int_to_ascii (registers, buf, register_bytes);
|
}
|
}
|
|
|
void
|
void
|
registers_from_string (char *buf)
|
registers_from_string (char *buf)
|
{
|
{
|
int len = strlen (buf);
|
int len = strlen (buf);
|
unsigned char *registers = get_regcache (current_inferior, 1)->registers;
|
unsigned char *registers = get_regcache (current_inferior, 1)->registers;
|
|
|
if (len != register_bytes * 2)
|
if (len != register_bytes * 2)
|
{
|
{
|
warning ("Wrong sized register packet (expected %d bytes, got %d)", 2*register_bytes, len);
|
warning ("Wrong sized register packet (expected %d bytes, got %d)", 2*register_bytes, len);
|
if (len > register_bytes * 2)
|
if (len > register_bytes * 2)
|
len = register_bytes * 2;
|
len = register_bytes * 2;
|
}
|
}
|
convert_ascii_to_int (buf, registers, len / 2);
|
convert_ascii_to_int (buf, registers, len / 2);
|
}
|
}
|
|
|
struct reg *
|
struct reg *
|
find_register_by_name (const char *name)
|
find_register_by_name (const char *name)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < num_registers; i++)
|
for (i = 0; i < num_registers; i++)
|
if (!strcmp (name, reg_defs[i].name))
|
if (!strcmp (name, reg_defs[i].name))
|
return ®_defs[i];
|
return ®_defs[i];
|
fatal ("Unknown register %s requested", name);
|
fatal ("Unknown register %s requested", name);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
find_regno (const char *name)
|
find_regno (const char *name)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < num_registers; i++)
|
for (i = 0; i < num_registers; i++)
|
if (!strcmp (name, reg_defs[i].name))
|
if (!strcmp (name, reg_defs[i].name))
|
return i;
|
return i;
|
fatal ("Unknown register %s requested", name);
|
fatal ("Unknown register %s requested", name);
|
return -1;
|
return -1;
|
}
|
}
|
|
|
struct reg *
|
struct reg *
|
find_register_by_number (int n)
|
find_register_by_number (int n)
|
{
|
{
|
return ®_defs[n];
|
return ®_defs[n];
|
}
|
}
|
|
|
int
|
int
|
register_size (int n)
|
register_size (int n)
|
{
|
{
|
return reg_defs[n].size / 8;
|
return reg_defs[n].size / 8;
|
}
|
}
|
|
|
static unsigned char *
|
static unsigned char *
|
register_data (int n, int fetch)
|
register_data (int n, int fetch)
|
{
|
{
|
unsigned char *registers
|
unsigned char *registers
|
= get_regcache (current_inferior, fetch)->registers;
|
= get_regcache (current_inferior, fetch)->registers;
|
|
|
return registers + (reg_defs[n].offset / 8);
|
return registers + (reg_defs[n].offset / 8);
|
}
|
}
|
|
|
void
|
void
|
supply_register (int n, const void *buf)
|
supply_register (int n, const void *buf)
|
{
|
{
|
memcpy (register_data (n, 0), buf, register_size (n));
|
memcpy (register_data (n, 0), buf, register_size (n));
|
}
|
}
|
|
|
void
|
void
|
supply_register_by_name (const char *name, const void *buf)
|
supply_register_by_name (const char *name, const void *buf)
|
{
|
{
|
supply_register (find_regno (name), buf);
|
supply_register (find_regno (name), buf);
|
}
|
}
|
|
|
void
|
void
|
collect_register (int n, void *buf)
|
collect_register (int n, void *buf)
|
{
|
{
|
memcpy (buf, register_data (n, 1), register_size (n));
|
memcpy (buf, register_data (n, 1), register_size (n));
|
}
|
}
|
|
|
void
|
void
|
collect_register_as_string (int n, char *buf)
|
collect_register_as_string (int n, char *buf)
|
{
|
{
|
convert_int_to_ascii (register_data (n, 1), buf, register_size (n));
|
convert_int_to_ascii (register_data (n, 1), buf, register_size (n));
|
}
|
}
|
|
|
void
|
void
|
collect_register_by_name (const char *name, void *buf)
|
collect_register_by_name (const char *name, void *buf)
|
{
|
{
|
collect_register (find_regno (name), buf);
|
collect_register (find_regno (name), buf);
|
}
|
}
|
|
|
