coregrind/m_gdbserver/regcache.c

   1 /* Register support routines for the remote server for GDB.
   2    Copyright (C) 2001, 2002, 2004, 2005, 2011
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6    It has been modified to integrate it in valgrind
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "server.h"
  24 #include "regdef.h"
  25
  26 /* The private data for the register cache.  Note that we have one
  27    per inferior; this is primarily for simplicity, as the performance
  28    benefit is minimal.  */
  29
  30 struct inferior_regcache_data
  31 {
  32    int registers_valid;
  33    unsigned char *registers;
  34    Bool *register_supplied; /* set to True once it has been supplied */
  35 };
  36
  37 static int register_bytes;
  38
  39 static struct reg *reg_defs;
  40 static int num_registers;
  41
  42 const char **gdbserver_expedite_regs;
  43
  44 static
  45 struct inferior_regcache_data * get_regcache (struct thread_info *inf,
  46                                               int fetch)
  47 {
  48    struct inferior_regcache_data *regcache;
  49
  50    regcache = (struct inferior_regcache_data *) inferior_regcache_data (inf);
  51
  52    if (regcache == NULL)
  53       fatal ("no register cache\n");
  54
  55    /* FIXME - fetch registers for INF */
  56    if (fetch && regcache->registers_valid == 0) {
  57       valgrind_fetch_registers (0);
  58       regcache->registers_valid = 1;
  59    }
  60
  61    return regcache;
  62 }
  63
  64 void regcache_invalidate_one (struct inferior_list_entry *entry)
  65 {
  66    struct thread_info *thread = (struct thread_info *) entry;
  67    struct inferior_regcache_data *regcache;
  68
  69    regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
  70
  71    if (regcache->registers_valid) {
  72       struct thread_info *saved_inferior = current_inferior;
  73
  74       current_inferior = thread;
  75       valgrind_store_registers (-1);
  76       current_inferior = saved_inferior;
  77    }
  78
  79    regcache->registers_valid = 0;
  80 }
  81
  82 void regcache_invalidate ()
  83 {
  84    for_each_inferior (&all_threads, regcache_invalidate_one);
  85 }
  86
  87 int registers_length (void)
  88 {
  89    return 2 * register_bytes;
  90 }
  91
  92 void *new_register_cache (void)
  93 {
  94    struct inferior_regcache_data *regcache;
  95
  96    regcache = malloc (sizeof (*regcache));
  97
  98    /* Make sure to zero-initialize the register cache when it is created,
  99       in case there are registers the target never fetches.  This way they'll
 100       read as zero instead of garbage.  */
 101    regcache->registers = calloc (1, register_bytes);
 102    if (regcache->registers == NULL)
 103       fatal ("Could not allocate register cache.\n");
 104
 105    regcache->register_supplied = calloc (1, num_registers);
 106    if (regcache->register_supplied == NULL)
 107       fatal ("Could not allocate register_supplied cache.\n");
 108
 109    regcache->registers_valid = 0;
 110
 111    return regcache;
 112 }
 113
 114 void free_register_cache (void *regcache_p)
 115 {
 116    struct inferior_regcache_data *regcache
 117       = (struct inferior_regcache_data *) regcache_p;
 118
 119    free (regcache->registers);
 120    free (regcache->register_supplied);
 121    free (regcache);
 122 }
 123
 124 /* if a regcache exists for entry, reallocate it.
 125    This is needed if the shadow registers are added.
 126    In such a case, a 2nd call to set_register_cache is done
 127    which will cause the reallocation of already created caches. */
 128 static
 129 void regcache_realloc_one (struct inferior_list_entry *entry)
 130 {
 131    struct thread_info *thread = (struct thread_info *) entry;
 132    struct inferior_regcache_data *regcache;
 133
 134    regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
 135
 136    if (regcache) {
 137       free_register_cache (regcache);
 138       set_inferior_regcache_data (thread, new_register_cache ());
 139    }
 140 }
 141
 142 void set_register_cache (struct reg *regs, int n)
 143 {
 144    int offset, i;
 145
 146    reg_defs = regs;
 147    num_registers = n;
 148
 149    offset = 0;
 150    for (i = 0; i < n; i++) {
 151       regs[i].offset = offset;
 152       offset += regs[i].size;
 153    }
 154
 155    register_bytes = offset / 8;
 156
 157    for_each_inferior (&all_threads, regcache_realloc_one);
 158 }
 159
 160 void registers_to_string (char *buf)
 161 {
 162    unsigned char *registers = get_regcache (current_inferior, 1)->registers;
 163
 164    convert_int_to_ascii (registers, buf, register_bytes);
 165 }
 166
 167 void registers_from_string (const char *buf)
 168 {
 169    int len = strlen (buf);
 170    unsigned char *registers = get_regcache (current_inferior, 1)->registers;
 171
 172    if (len != register_bytes * 2) {
 173       warning ("Wrong sized register packet (expected %d bytes, got %d)\n",
 174                2*register_bytes, len);
 175       if (len > register_bytes * 2)
 176          len = register_bytes * 2;
 177    }
 178    convert_ascii_to_int (buf, registers, len / 2);
 179 }
 180
 181 int find_regno (const char *name)
 182 {
 183    int i;
 184
 185    for (i = 0; i < num_registers; i++)
 186       if (!strcmp (name, reg_defs[i].name))
 187          return i;
 188    fatal ("Unknown register %s requested\n", name);
 189    return -1;
 190 }
 191
 192 struct reg *find_register_by_number (int n)
 193 {
 194    return &reg_defs[n];
 195 }
 196
 197 int register_size (int n)
 198 {
 199    return reg_defs[n].size / 8;
 200 }
 201
 202 static
 203 unsigned char *register_data (int n, int fetch)
 204 {
 205    unsigned char *registers
 206       = get_regcache (current_inferior, fetch)->registers;
 207
 208    return registers + (reg_defs[n].offset / 8);
 209 }
 210 static
 211 unsigned char *register_data_for_supply (int n, int fetch, Bool *mod)
 212 {
 213    struct inferior_regcache_data * cache
 214       = get_regcache (current_inferior, fetch);
 215    unsigned char *registers = cache->registers;
 216
 217    if (cache->register_supplied[n])
 218       *mod = False;
 219    else
 220       *mod = True;
 221    cache->register_supplied[n] = True;
 222    return registers + (reg_defs[n].offset / 8);
 223 }
 224
 225 void supply_register (int n, const void *buf, Bool *mod)
 226 {
 227    Bool new;
 228    VG_(dmemcpy) (register_data_for_supply (n, 0, &new),
 229                  buf, register_size (n), mod);
 230    if (new)
 231       *mod = True;
 232 }
 233
 234 void supply_register_from_string (int n, const char *buf, Bool *mod)
 235 {
 236    Bool new;
 237    unsigned char bytes_register[register_size (n)];
 238    convert_ascii_to_int (buf, bytes_register, register_size (n));
 239    VG_(dmemcpy) (register_data_for_supply (n, 0, &new),
 240                  bytes_register, register_size (n), mod);
 241    if (new)
 242       *mod = True;
 243 }
 244
 245 void supply_register_by_name (const char *name, const void *buf, Bool *mod)
 246 {
 247    supply_register (find_regno (name), buf, mod);
 248 }
 249
 250 void collect_register (int n, void *buf)
 251 {
 252    VG_(memcpy) (buf, register_data (n, 1), register_size (n));
 253 }
 254
 255 void collect_register_as_string (int n, char *buf)
 256 {
 257    convert_int_to_ascii (register_data (n, 1), buf, register_size (n));
 258 }
 259
 260 void collect_register_by_name (const char *name, void *buf)
 261 {
 262    collect_register (find_regno (name), buf);
 263 }