198944Sobrien/* Cache and manage the values of registers for GDB, the GNU debugger. 298944Sobrien 3130803Smarcel Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 4130803Smarcel 2001, 2002, 2004 Free Software Foundation, Inc. 5130803Smarcel 698944Sobrien This file is part of GDB. 798944Sobrien 898944Sobrien This program is free software; you can redistribute it and/or modify 998944Sobrien it under the terms of the GNU General Public License as published by 1098944Sobrien the Free Software Foundation; either version 2 of the License, or 1198944Sobrien (at your option) any later version. 1298944Sobrien 1398944Sobrien This program is distributed in the hope that it will be useful, 1498944Sobrien but WITHOUT ANY WARRANTY; without even the implied warranty of 1598944Sobrien MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1698944Sobrien GNU General Public License for more details. 1798944Sobrien 1898944Sobrien You should have received a copy of the GNU General Public License 1998944Sobrien along with this program; if not, write to the Free Software 2098944Sobrien Foundation, Inc., 59 Temple Place - Suite 330, 2198944Sobrien Boston, MA 02111-1307, USA. */ 2298944Sobrien 2398944Sobrien#include "defs.h" 2498944Sobrien#include "inferior.h" 2598944Sobrien#include "target.h" 2698944Sobrien#include "gdbarch.h" 2798944Sobrien#include "gdbcmd.h" 2898944Sobrien#include "regcache.h" 29130803Smarcel#include "reggroups.h" 3098944Sobrien#include "gdb_assert.h" 31130803Smarcel#include "gdb_string.h" 32130803Smarcel#include "gdbcmd.h" /* For maintenanceprintlist. */ 3398944Sobrien 3498944Sobrien/* 3598944Sobrien * DATA STRUCTURE 3698944Sobrien * 3798944Sobrien * Here is the actual register cache. 3898944Sobrien */ 3998944Sobrien 40130803Smarcel/* Per-architecture object describing the layout of a register cache. 41130803Smarcel Computed once when the architecture is created */ 42130803Smarcel 43130803Smarcelstruct gdbarch_data *regcache_descr_handle; 44130803Smarcel 45130803Smarcelstruct regcache_descr 46130803Smarcel{ 47130803Smarcel /* The architecture this descriptor belongs to. */ 48130803Smarcel struct gdbarch *gdbarch; 49130803Smarcel 50130803Smarcel /* Is this a ``legacy'' register cache? Such caches reserve space 51130803Smarcel for raw and pseudo registers and allow access to both. */ 52130803Smarcel int legacy_p; 53130803Smarcel 54130803Smarcel /* The raw register cache. Each raw (or hard) register is supplied 55130803Smarcel by the target interface. The raw cache should not contain 56130803Smarcel redundant information - if the PC is constructed from two 57130803Smarcel registers then those regigisters and not the PC lives in the raw 58130803Smarcel cache. */ 59130803Smarcel int nr_raw_registers; 60130803Smarcel long sizeof_raw_registers; 61130803Smarcel long sizeof_raw_register_valid_p; 62130803Smarcel 63130803Smarcel /* The cooked register space. Each cooked register in the range 64130803Smarcel [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw 65130803Smarcel register. The remaining [NR_RAW_REGISTERS 66130803Smarcel .. NR_COOKED_REGISTERS) (a.k.a. pseudo regiters) are mapped onto 67130803Smarcel both raw registers and memory by the architecture methods 68130803Smarcel gdbarch_register_read and gdbarch_register_write. */ 69130803Smarcel int nr_cooked_registers; 70130803Smarcel long sizeof_cooked_registers; 71130803Smarcel long sizeof_cooked_register_valid_p; 72130803Smarcel 73130803Smarcel /* Offset and size (in 8 bit bytes), of reach register in the 74130803Smarcel register cache. All registers (including those in the range 75130803Smarcel [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset. 76130803Smarcel Assigning all registers an offset makes it possible to keep 77130803Smarcel legacy code, such as that found in read_register_bytes() and 78130803Smarcel write_register_bytes() working. */ 79130803Smarcel long *register_offset; 80130803Smarcel long *sizeof_register; 81130803Smarcel 82130803Smarcel /* Cached table containing the type of each register. */ 83130803Smarcel struct type **register_type; 84130803Smarcel}; 85130803Smarcel 86130803Smarcelstatic void 87130803Smarcelinit_legacy_regcache_descr (struct gdbarch *gdbarch, 88130803Smarcel struct regcache_descr *descr) 89130803Smarcel{ 90130803Smarcel int i; 91130803Smarcel /* FIXME: cagney/2002-05-11: gdbarch_data() should take that 92130803Smarcel ``gdbarch'' as a parameter. */ 93130803Smarcel gdb_assert (gdbarch != NULL); 94130803Smarcel 95130803Smarcel /* Compute the offset of each register. Legacy architectures define 96130803Smarcel DEPRECATED_REGISTER_BYTE() so use that. */ 97130803Smarcel /* FIXME: cagney/2002-11-07: Instead of using 98130803Smarcel DEPRECATED_REGISTER_BYTE() this code should, as is done in 99130803Smarcel init_regcache_descr(), compute the offets at runtime. This 100130803Smarcel currently isn't possible as some ISAs define overlapping register 101130803Smarcel regions - see the mess in read_register_bytes() and 102130803Smarcel write_register_bytes() registers. */ 103130803Smarcel descr->sizeof_register 104130803Smarcel = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long); 105130803Smarcel descr->register_offset 106130803Smarcel = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long); 107130803Smarcel for (i = 0; i < descr->nr_cooked_registers; i++) 108130803Smarcel { 109130803Smarcel /* FIXME: cagney/2001-12-04: This code shouldn't need to use 110130803Smarcel DEPRECATED_REGISTER_BYTE(). Unfortunately, legacy code likes 111130803Smarcel to lay the buffer out so that certain registers just happen 112130803Smarcel to overlap. Ulgh! New targets use gdbarch's register 113130803Smarcel read/write and entirely avoid this uglyness. */ 114130803Smarcel descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i); 115130803Smarcel descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i); 116130803Smarcel gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i)); 117130803Smarcel gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_SIZE (i)); 118130803Smarcel } 119130803Smarcel 120130803Smarcel /* Compute the real size of the register buffer. Start out by 121130803Smarcel trusting DEPRECATED_REGISTER_BYTES, but then adjust it upwards 122130803Smarcel should that be found to not be sufficient. */ 123130803Smarcel /* FIXME: cagney/2002-11-05: Instead of using the macro 124130803Smarcel DEPRECATED_REGISTER_BYTES, this code should, as is done in 125130803Smarcel init_regcache_descr(), compute the total number of register bytes 126130803Smarcel using the accumulated offsets. */ 127130803Smarcel descr->sizeof_cooked_registers = DEPRECATED_REGISTER_BYTES; /* OK */ 128130803Smarcel for (i = 0; i < descr->nr_cooked_registers; i++) 129130803Smarcel { 130130803Smarcel long regend; 131130803Smarcel /* Keep extending the buffer so that there is always enough 132130803Smarcel space for all registers. The comparison is necessary since 133130803Smarcel legacy code is free to put registers in random places in the 134130803Smarcel buffer separated by holes. Once DEPRECATED_REGISTER_BYTE() 135130803Smarcel is killed this can be greatly simplified. */ 136130803Smarcel regend = descr->register_offset[i] + descr->sizeof_register[i]; 137130803Smarcel if (descr->sizeof_cooked_registers < regend) 138130803Smarcel descr->sizeof_cooked_registers = regend; 139130803Smarcel } 140130803Smarcel /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers 141130803Smarcel in the register cache. Unfortunately some architectures still 142130803Smarcel rely on this and the pseudo_register_write() method. */ 143130803Smarcel descr->sizeof_raw_registers = descr->sizeof_cooked_registers; 144130803Smarcel} 145130803Smarcel 146130803Smarcelstatic void * 147130803Smarcelinit_regcache_descr (struct gdbarch *gdbarch) 148130803Smarcel{ 149130803Smarcel int i; 150130803Smarcel struct regcache_descr *descr; 151130803Smarcel gdb_assert (gdbarch != NULL); 152130803Smarcel 153130803Smarcel /* Create an initial, zero filled, table. */ 154130803Smarcel descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr); 155130803Smarcel descr->gdbarch = gdbarch; 156130803Smarcel 157130803Smarcel /* Total size of the register space. The raw registers are mapped 158130803Smarcel directly onto the raw register cache while the pseudo's are 159130803Smarcel either mapped onto raw-registers or memory. */ 160130803Smarcel descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS; 161130803Smarcel descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS; 162130803Smarcel 163130803Smarcel /* Fill in a table of register types. */ 164130803Smarcel descr->register_type 165130803Smarcel = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *); 166130803Smarcel for (i = 0; i < descr->nr_cooked_registers; i++) 167130803Smarcel { 168130803Smarcel if (gdbarch_register_type_p (gdbarch)) 169130803Smarcel { 170130803Smarcel gdb_assert (!DEPRECATED_REGISTER_VIRTUAL_TYPE_P ()); /* OK */ 171130803Smarcel descr->register_type[i] = gdbarch_register_type (gdbarch, i); 172130803Smarcel } 173130803Smarcel else 174130803Smarcel descr->register_type[i] = DEPRECATED_REGISTER_VIRTUAL_TYPE (i); /* OK */ 175130803Smarcel } 176130803Smarcel 177130803Smarcel /* Construct a strictly RAW register cache. Don't allow pseudo's 178130803Smarcel into the register cache. */ 179130803Smarcel descr->nr_raw_registers = NUM_REGS; 180130803Smarcel 181130803Smarcel /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p 182130803Smarcel array. This pretects GDB from erant code that accesses elements 183130803Smarcel of the global register_valid_p[] array in the range [NUM_REGS 184130803Smarcel .. NUM_REGS + NUM_PSEUDO_REGS). */ 185130803Smarcel descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p; 186130803Smarcel 187130803Smarcel /* If an old style architecture, fill in the remainder of the 188130803Smarcel register cache descriptor using the register macros. */ 189130803Smarcel /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or 190130803Smarcel DEPRECATED_REGISTER_RAW_SIZE are still present, things are most likely 191130803Smarcel totally screwed. Ex: an architecture with raw register sizes 192130803Smarcel smaller than what DEPRECATED_REGISTER_BYTE indicates; non 193130803Smarcel monotonic DEPRECATED_REGISTER_BYTE values. For GDB 6 check for 194130803Smarcel these nasty methods and fall back to legacy code when present. 195130803Smarcel Sigh! */ 196130803Smarcel if ((!gdbarch_pseudo_register_read_p (gdbarch) 197130803Smarcel && !gdbarch_pseudo_register_write_p (gdbarch) 198130803Smarcel && !gdbarch_register_type_p (gdbarch)) 199130803Smarcel || DEPRECATED_REGISTER_BYTE_P () 200130803Smarcel || DEPRECATED_REGISTER_RAW_SIZE_P ()) 201130803Smarcel { 202130803Smarcel descr->legacy_p = 1; 203130803Smarcel init_legacy_regcache_descr (gdbarch, descr); 204130803Smarcel return descr; 205130803Smarcel } 206130803Smarcel 207130803Smarcel /* Lay out the register cache. 208130803Smarcel 209130803Smarcel NOTE: cagney/2002-05-22: Only register_type() is used when 210130803Smarcel constructing the register cache. It is assumed that the 211130803Smarcel register's raw size, virtual size and type length are all the 212130803Smarcel same. */ 213130803Smarcel 214130803Smarcel { 215130803Smarcel long offset = 0; 216130803Smarcel descr->sizeof_register 217130803Smarcel = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long); 218130803Smarcel descr->register_offset 219130803Smarcel = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long); 220130803Smarcel for (i = 0; i < descr->nr_cooked_registers; i++) 221130803Smarcel { 222130803Smarcel descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]); 223130803Smarcel descr->register_offset[i] = offset; 224130803Smarcel offset += descr->sizeof_register[i]; 225130803Smarcel gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]); 226130803Smarcel } 227130803Smarcel /* Set the real size of the register cache buffer. */ 228130803Smarcel descr->sizeof_cooked_registers = offset; 229130803Smarcel } 230130803Smarcel 231130803Smarcel /* FIXME: cagney/2002-05-22: Should only need to allocate space for 232130803Smarcel the raw registers. Unfortunately some code still accesses the 233130803Smarcel register array directly using the global registers[]. Until that 234130803Smarcel code has been purged, play safe and over allocating the register 235130803Smarcel buffer. Ulgh! */ 236130803Smarcel descr->sizeof_raw_registers = descr->sizeof_cooked_registers; 237130803Smarcel 238130803Smarcel /* Sanity check. Confirm that there is agreement between the 239130803Smarcel regcache and the target's redundant DEPRECATED_REGISTER_BYTE (new 240130803Smarcel targets should not even be defining it). */ 241130803Smarcel for (i = 0; i < descr->nr_cooked_registers; i++) 242130803Smarcel { 243130803Smarcel if (DEPRECATED_REGISTER_BYTE_P ()) 244130803Smarcel gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i)); 245130803Smarcel#if 0 246130803Smarcel gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_RAW_SIZE (i)); 247130803Smarcel gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i)); 248130803Smarcel#endif 249130803Smarcel } 250130803Smarcel /* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i)); */ 251130803Smarcel 252130803Smarcel return descr; 253130803Smarcel} 254130803Smarcel 255130803Smarcelstatic struct regcache_descr * 256130803Smarcelregcache_descr (struct gdbarch *gdbarch) 257130803Smarcel{ 258130803Smarcel return gdbarch_data (gdbarch, regcache_descr_handle); 259130803Smarcel} 260130803Smarcel 261130803Smarcel/* Utility functions returning useful register attributes stored in 262130803Smarcel the regcache descr. */ 263130803Smarcel 264130803Smarcelstruct type * 265130803Smarcelregister_type (struct gdbarch *gdbarch, int regnum) 266130803Smarcel{ 267130803Smarcel struct regcache_descr *descr = regcache_descr (gdbarch); 268130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers); 269130803Smarcel return descr->register_type[regnum]; 270130803Smarcel} 271130803Smarcel 272130803Smarcel/* Utility functions returning useful register attributes stored in 273130803Smarcel the regcache descr. */ 274130803Smarcel 275130803Smarcelint 276130803Smarcelregister_size (struct gdbarch *gdbarch, int regnum) 277130803Smarcel{ 278130803Smarcel struct regcache_descr *descr = regcache_descr (gdbarch); 279130803Smarcel int size; 280130803Smarcel gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS)); 281130803Smarcel size = descr->sizeof_register[regnum]; 282130803Smarcel /* NB: The deprecated DEPRECATED_REGISTER_RAW_SIZE, if not provided, defaults 283130803Smarcel to the size of the register's type. */ 284130803Smarcel gdb_assert (size == DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* OK */ 285130803Smarcel /* NB: Don't check the register's virtual size. It, in say the case 286130803Smarcel of the MIPS, may not match the raw size! */ 287130803Smarcel return size; 288130803Smarcel} 289130803Smarcel 290130803Smarcel/* The register cache for storing raw register values. */ 291130803Smarcel 292130803Smarcelstruct regcache 293130803Smarcel{ 294130803Smarcel struct regcache_descr *descr; 295130803Smarcel /* The register buffers. A read-only register cache can hold the 296130803Smarcel full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write 297130803Smarcel register cache can only hold [0 .. NUM_REGS). */ 298130803Smarcel char *registers; 299130803Smarcel char *register_valid_p; 300130803Smarcel /* Is this a read-only cache? A read-only cache is used for saving 301130803Smarcel the target's register state (e.g, across an inferior function 302130803Smarcel call or just before forcing a function return). A read-only 303130803Smarcel cache can only be updated via the methods regcache_dup() and 304130803Smarcel regcache_cpy(). The actual contents are determined by the 305130803Smarcel reggroup_save and reggroup_restore methods. */ 306130803Smarcel int readonly_p; 307130803Smarcel}; 308130803Smarcel 309130803Smarcelstruct regcache * 310130803Smarcelregcache_xmalloc (struct gdbarch *gdbarch) 311130803Smarcel{ 312130803Smarcel struct regcache_descr *descr; 313130803Smarcel struct regcache *regcache; 314130803Smarcel gdb_assert (gdbarch != NULL); 315130803Smarcel descr = regcache_descr (gdbarch); 316130803Smarcel regcache = XMALLOC (struct regcache); 317130803Smarcel regcache->descr = descr; 318130803Smarcel regcache->registers 319130803Smarcel = XCALLOC (descr->sizeof_raw_registers, char); 320130803Smarcel regcache->register_valid_p 321130803Smarcel = XCALLOC (descr->sizeof_raw_register_valid_p, char); 322130803Smarcel regcache->readonly_p = 1; 323130803Smarcel return regcache; 324130803Smarcel} 325130803Smarcel 326130803Smarcelvoid 327130803Smarcelregcache_xfree (struct regcache *regcache) 328130803Smarcel{ 329130803Smarcel if (regcache == NULL) 330130803Smarcel return; 331130803Smarcel xfree (regcache->registers); 332130803Smarcel xfree (regcache->register_valid_p); 333130803Smarcel xfree (regcache); 334130803Smarcel} 335130803Smarcel 336130803Smarcelstatic void 337130803Smarceldo_regcache_xfree (void *data) 338130803Smarcel{ 339130803Smarcel regcache_xfree (data); 340130803Smarcel} 341130803Smarcel 342130803Smarcelstruct cleanup * 343130803Smarcelmake_cleanup_regcache_xfree (struct regcache *regcache) 344130803Smarcel{ 345130803Smarcel return make_cleanup (do_regcache_xfree, regcache); 346130803Smarcel} 347130803Smarcel 348130803Smarcel/* Return REGCACHE's architecture. */ 349130803Smarcel 350130803Smarcelstruct gdbarch * 351130803Smarcelget_regcache_arch (const struct regcache *regcache) 352130803Smarcel{ 353130803Smarcel return regcache->descr->gdbarch; 354130803Smarcel} 355130803Smarcel 356130803Smarcel/* Return a pointer to register REGNUM's buffer cache. */ 357130803Smarcel 358130803Smarcelstatic char * 359130803Smarcelregister_buffer (const struct regcache *regcache, int regnum) 360130803Smarcel{ 361130803Smarcel return regcache->registers + regcache->descr->register_offset[regnum]; 362130803Smarcel} 363130803Smarcel 364130803Smarcelvoid 365130803Smarcelregcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read, 366130803Smarcel void *src) 367130803Smarcel{ 368130803Smarcel struct gdbarch *gdbarch = dst->descr->gdbarch; 369130803Smarcel char buf[MAX_REGISTER_SIZE]; 370130803Smarcel int regnum; 371130803Smarcel /* The DST should be `read-only', if it wasn't then the save would 372130803Smarcel end up trying to write the register values back out to the 373130803Smarcel target. */ 374130803Smarcel gdb_assert (dst->readonly_p); 375130803Smarcel /* Clear the dest. */ 376130803Smarcel memset (dst->registers, 0, dst->descr->sizeof_cooked_registers); 377130803Smarcel memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p); 378130803Smarcel /* Copy over any registers (identified by their membership in the 379130803Smarcel save_reggroup) and mark them as valid. The full [0 .. NUM_REGS + 380130803Smarcel NUM_PSEUDO_REGS) range is checked since some architectures need 381130803Smarcel to save/restore `cooked' registers that live in memory. */ 382130803Smarcel for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++) 383130803Smarcel { 384130803Smarcel if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup)) 385130803Smarcel { 386130803Smarcel int valid = cooked_read (src, regnum, buf); 387130803Smarcel if (valid) 388130803Smarcel { 389130803Smarcel memcpy (register_buffer (dst, regnum), buf, 390130803Smarcel register_size (gdbarch, regnum)); 391130803Smarcel dst->register_valid_p[regnum] = 1; 392130803Smarcel } 393130803Smarcel } 394130803Smarcel } 395130803Smarcel} 396130803Smarcel 397130803Smarcelvoid 398130803Smarcelregcache_restore (struct regcache *dst, 399130803Smarcel regcache_cooked_read_ftype *cooked_read, 400130803Smarcel void *src) 401130803Smarcel{ 402130803Smarcel struct gdbarch *gdbarch = dst->descr->gdbarch; 403130803Smarcel char buf[MAX_REGISTER_SIZE]; 404130803Smarcel int regnum; 405130803Smarcel /* The dst had better not be read-only. If it is, the `restore' 406130803Smarcel doesn't make much sense. */ 407130803Smarcel gdb_assert (!dst->readonly_p); 408130803Smarcel /* Copy over any registers, being careful to only restore those that 409130803Smarcel were both saved and need to be restored. The full [0 .. NUM_REGS 410130803Smarcel + NUM_PSEUDO_REGS) range is checked since some architectures need 411130803Smarcel to save/restore `cooked' registers that live in memory. */ 412130803Smarcel for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++) 413130803Smarcel { 414130803Smarcel if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup)) 415130803Smarcel { 416130803Smarcel int valid = cooked_read (src, regnum, buf); 417130803Smarcel if (valid) 418130803Smarcel regcache_cooked_write (dst, regnum, buf); 419130803Smarcel } 420130803Smarcel } 421130803Smarcel} 422130803Smarcel 423130803Smarcelstatic int 424130803Smarceldo_cooked_read (void *src, int regnum, void *buf) 425130803Smarcel{ 426130803Smarcel struct regcache *regcache = src; 427130803Smarcel if (!regcache->register_valid_p[regnum] && regcache->readonly_p) 428130803Smarcel /* Don't even think about fetching a register from a read-only 429130803Smarcel cache when the register isn't yet valid. There isn't a target 430130803Smarcel from which the register value can be fetched. */ 431130803Smarcel return 0; 432130803Smarcel regcache_cooked_read (regcache, regnum, buf); 433130803Smarcel return 1; 434130803Smarcel} 435130803Smarcel 436130803Smarcel 437130803Smarcelvoid 438130803Smarcelregcache_cpy (struct regcache *dst, struct regcache *src) 439130803Smarcel{ 440130803Smarcel int i; 441130803Smarcel char *buf; 442130803Smarcel gdb_assert (src != NULL && dst != NULL); 443130803Smarcel gdb_assert (src->descr->gdbarch == dst->descr->gdbarch); 444130803Smarcel gdb_assert (src != dst); 445130803Smarcel gdb_assert (src->readonly_p || dst->readonly_p); 446130803Smarcel if (!src->readonly_p) 447130803Smarcel regcache_save (dst, do_cooked_read, src); 448130803Smarcel else if (!dst->readonly_p) 449130803Smarcel regcache_restore (dst, do_cooked_read, src); 450130803Smarcel else 451130803Smarcel regcache_cpy_no_passthrough (dst, src); 452130803Smarcel} 453130803Smarcel 454130803Smarcelvoid 455130803Smarcelregcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src) 456130803Smarcel{ 457130803Smarcel int i; 458130803Smarcel gdb_assert (src != NULL && dst != NULL); 459130803Smarcel gdb_assert (src->descr->gdbarch == dst->descr->gdbarch); 460130803Smarcel /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough 461130803Smarcel move of data into the current_regcache(). Doing this would be 462130803Smarcel silly - it would mean that valid_p would be completely invalid. */ 463130803Smarcel gdb_assert (dst != current_regcache); 464130803Smarcel memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers); 465130803Smarcel memcpy (dst->register_valid_p, src->register_valid_p, 466130803Smarcel dst->descr->sizeof_raw_register_valid_p); 467130803Smarcel} 468130803Smarcel 469130803Smarcelstruct regcache * 470130803Smarcelregcache_dup (struct regcache *src) 471130803Smarcel{ 472130803Smarcel struct regcache *newbuf; 473130803Smarcel gdb_assert (current_regcache != NULL); 474130803Smarcel newbuf = regcache_xmalloc (src->descr->gdbarch); 475130803Smarcel regcache_cpy (newbuf, src); 476130803Smarcel return newbuf; 477130803Smarcel} 478130803Smarcel 479130803Smarcelstruct regcache * 480130803Smarcelregcache_dup_no_passthrough (struct regcache *src) 481130803Smarcel{ 482130803Smarcel struct regcache *newbuf; 483130803Smarcel gdb_assert (current_regcache != NULL); 484130803Smarcel newbuf = regcache_xmalloc (src->descr->gdbarch); 485130803Smarcel regcache_cpy_no_passthrough (newbuf, src); 486130803Smarcel return newbuf; 487130803Smarcel} 488130803Smarcel 489130803Smarcelint 490130803Smarcelregcache_valid_p (struct regcache *regcache, int regnum) 491130803Smarcel{ 492130803Smarcel gdb_assert (regcache != NULL); 493130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 494130803Smarcel return regcache->register_valid_p[regnum]; 495130803Smarcel} 496130803Smarcel 497130803Smarcelchar * 498130803Smarceldeprecated_grub_regcache_for_registers (struct regcache *regcache) 499130803Smarcel{ 500130803Smarcel return regcache->registers; 501130803Smarcel} 502130803Smarcel 503130803Smarcel/* Global structure containing the current regcache. */ 504130803Smarcel/* FIXME: cagney/2002-05-11: The two global arrays registers[] and 505130803Smarcel deprecated_register_valid[] currently point into this structure. */ 506130803Smarcelstruct regcache *current_regcache; 507130803Smarcel 50898944Sobrien/* NOTE: this is a write-through cache. There is no "dirty" bit for 50998944Sobrien recording if the register values have been changed (eg. by the 51098944Sobrien user). Therefore all registers must be written back to the 51198944Sobrien target when appropriate. */ 51298944Sobrien 51398944Sobrien/* REGISTERS contains the cached register values (in target byte order). */ 51498944Sobrien 515130803Smarcelchar *deprecated_registers; 51698944Sobrien 517130803Smarcel/* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched, 51898944Sobrien 1 if it has been fetched, and 51998944Sobrien -1 if the register value was not available. 52098944Sobrien 521130803Smarcel "Not available" indicates that the target is not not able to supply 522130803Smarcel the register at this state. The register may become available at a 523130803Smarcel later time (after the next resume). This often occures when GDB is 524130803Smarcel manipulating a target that contains only a snapshot of the entire 525130803Smarcel system being debugged - some of the registers in such a system may 526130803Smarcel not have been saved. */ 52798944Sobrien 528130803Smarcelsigned char *deprecated_register_valid; 529130803Smarcel 53098944Sobrien/* The thread/process associated with the current set of registers. */ 53198944Sobrien 53298944Sobrienstatic ptid_t registers_ptid; 53398944Sobrien 53498944Sobrien/* 53598944Sobrien * FUNCTIONS: 53698944Sobrien */ 53798944Sobrien 53898944Sobrien/* REGISTER_CACHED() 53998944Sobrien 54098944Sobrien Returns 0 if the value is not in the cache (needs fetch). 54198944Sobrien >0 if the value is in the cache. 54298944Sobrien <0 if the value is permanently unavailable (don't ask again). */ 54398944Sobrien 54498944Sobrienint 54598944Sobrienregister_cached (int regnum) 54698944Sobrien{ 547130803Smarcel return deprecated_register_valid[regnum]; 54898944Sobrien} 54998944Sobrien 55098944Sobrien/* Record that REGNUM's value is cached if STATE is >0, uncached but 55198944Sobrien fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */ 55298944Sobrien 55398944Sobrienvoid 55498944Sobrienset_register_cached (int regnum, int state) 55598944Sobrien{ 556130803Smarcel gdb_assert (regnum >= 0); 557130803Smarcel gdb_assert (regnum < current_regcache->descr->nr_raw_registers); 558130803Smarcel current_regcache->register_valid_p[regnum] = state; 55998944Sobrien} 56098944Sobrien 56198944Sobrien/* Return whether register REGNUM is a real register. */ 56298944Sobrien 56398944Sobrienstatic int 56498944Sobrienreal_register (int regnum) 56598944Sobrien{ 56698944Sobrien return regnum >= 0 && regnum < NUM_REGS; 56798944Sobrien} 56898944Sobrien 56998944Sobrien/* Low level examining and depositing of registers. 57098944Sobrien 57198944Sobrien The caller is responsible for making sure that the inferior is 57298944Sobrien stopped before calling the fetching routines, or it will get 57398944Sobrien garbage. (a change from GDB version 3, in which the caller got the 57498944Sobrien value from the last stop). */ 57598944Sobrien 57698944Sobrien/* REGISTERS_CHANGED () 57798944Sobrien 57898944Sobrien Indicate that registers may have changed, so invalidate the cache. */ 57998944Sobrien 58098944Sobrienvoid 58198944Sobrienregisters_changed (void) 58298944Sobrien{ 58398944Sobrien int i; 58498944Sobrien 58598944Sobrien registers_ptid = pid_to_ptid (-1); 58698944Sobrien 58798944Sobrien /* Force cleanup of any alloca areas if using C alloca instead of 58898944Sobrien a builtin alloca. This particular call is used to clean up 58998944Sobrien areas allocated by low level target code which may build up 59098944Sobrien during lengthy interactions between gdb and the target before 59198944Sobrien gdb gives control to the user (ie watchpoints). */ 59298944Sobrien alloca (0); 59398944Sobrien 594130803Smarcel for (i = 0; i < current_regcache->descr->nr_raw_registers; i++) 59598944Sobrien set_register_cached (i, 0); 59698944Sobrien 59798944Sobrien if (registers_changed_hook) 59898944Sobrien registers_changed_hook (); 59998944Sobrien} 60098944Sobrien 601130803Smarcel/* DEPRECATED_REGISTERS_FETCHED () 60298944Sobrien 60398944Sobrien Indicate that all registers have been fetched, so mark them all valid. */ 60498944Sobrien 60598944Sobrien/* NOTE: cagney/2001-12-04: This function does not set valid on the 60698944Sobrien pseudo-register range since pseudo registers are always supplied 60798944Sobrien using supply_register(). */ 60898944Sobrien/* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target 60998944Sobrien code was blatting the registers[] array and then calling this. 61098944Sobrien Since targets should only be using supply_register() the need for 61198944Sobrien this function/hack is eliminated. */ 61298944Sobrien 61398944Sobrienvoid 614130803Smarceldeprecated_registers_fetched (void) 61598944Sobrien{ 61698944Sobrien int i; 61798944Sobrien 61898944Sobrien for (i = 0; i < NUM_REGS; i++) 61998944Sobrien set_register_cached (i, 1); 62098944Sobrien /* Do not assume that the pseudo-regs have also been fetched. 62198944Sobrien Fetching all real regs NEVER accounts for pseudo-regs. */ 62298944Sobrien} 62398944Sobrien 624130803Smarcel/* deprecated_read_register_bytes and deprecated_write_register_bytes 625130803Smarcel are generally a *BAD* idea. They are inefficient because they need 626130803Smarcel to check for partial updates, which can only be done by scanning 627130803Smarcel through all of the registers and seeing if the bytes that are being 628130803Smarcel read/written fall inside of an invalid register. [The main reason 629130803Smarcel this is necessary is that register sizes can vary, so a simple 630130803Smarcel index won't suffice.] It is far better to call read_register_gen 631130803Smarcel and write_register_gen if you want to get at the raw register 632130803Smarcel contents, as it only takes a regnum as an argument, and therefore 633130803Smarcel can't do a partial register update. 63498944Sobrien 63598944Sobrien Prior to the recent fixes to check for partial updates, both read 636130803Smarcel and deprecated_write_register_bytes always checked to see if any 637130803Smarcel registers were stale, and then called target_fetch_registers (-1) 638130803Smarcel to update the whole set. This caused really slowed things down for 639130803Smarcel remote targets. */ 64098944Sobrien 64198944Sobrien/* Copy INLEN bytes of consecutive data from registers 64298944Sobrien starting with the INREGBYTE'th byte of register data 64398944Sobrien into memory at MYADDR. */ 64498944Sobrien 64598944Sobrienvoid 646130803Smarceldeprecated_read_register_bytes (int in_start, char *in_buf, int in_len) 64798944Sobrien{ 64898944Sobrien int in_end = in_start + in_len; 64998944Sobrien int regnum; 650130803Smarcel char reg_buf[MAX_REGISTER_SIZE]; 65198944Sobrien 65298944Sobrien /* See if we are trying to read bytes from out-of-date registers. If so, 65398944Sobrien update just those registers. */ 65498944Sobrien 65598944Sobrien for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) 65698944Sobrien { 65798944Sobrien int reg_start; 65898944Sobrien int reg_end; 65998944Sobrien int reg_len; 66098944Sobrien int start; 66198944Sobrien int end; 66298944Sobrien int byte; 66398944Sobrien 664130803Smarcel reg_start = DEPRECATED_REGISTER_BYTE (regnum); 665130803Smarcel reg_len = DEPRECATED_REGISTER_RAW_SIZE (regnum); 66698944Sobrien reg_end = reg_start + reg_len; 66798944Sobrien 66898944Sobrien if (reg_end <= in_start || in_end <= reg_start) 66998944Sobrien /* The range the user wants to read doesn't overlap with regnum. */ 67098944Sobrien continue; 67198944Sobrien 67298944Sobrien if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0') 67398944Sobrien /* Force the cache to fetch the entire register. */ 674130803Smarcel deprecated_read_register_gen (regnum, reg_buf); 67598944Sobrien else 67698944Sobrien /* Legacy note: even though this register is ``invalid'' we 67798944Sobrien still need to return something. It would appear that some 67898944Sobrien code relies on apparent gaps in the register array also 67998944Sobrien being returned. */ 68098944Sobrien /* FIXME: cagney/2001-08-18: This is just silly. It defeats 68198944Sobrien the entire register read/write flow of control. Must 68298944Sobrien resist temptation to return 0xdeadbeef. */ 683130803Smarcel memcpy (reg_buf, &deprecated_registers[reg_start], reg_len); 68498944Sobrien 68598944Sobrien /* Legacy note: This function, for some reason, allows a NULL 68698944Sobrien input buffer. If the buffer is NULL, the registers are still 68798944Sobrien fetched, just the final transfer is skipped. */ 68898944Sobrien if (in_buf == NULL) 68998944Sobrien continue; 69098944Sobrien 69198944Sobrien /* start = max (reg_start, in_start) */ 69298944Sobrien if (reg_start > in_start) 69398944Sobrien start = reg_start; 69498944Sobrien else 69598944Sobrien start = in_start; 69698944Sobrien 69798944Sobrien /* end = min (reg_end, in_end) */ 69898944Sobrien if (reg_end < in_end) 69998944Sobrien end = reg_end; 70098944Sobrien else 70198944Sobrien end = in_end; 70298944Sobrien 70398944Sobrien /* Transfer just the bytes common to both IN_BUF and REG_BUF */ 70498944Sobrien for (byte = start; byte < end; byte++) 70598944Sobrien { 70698944Sobrien in_buf[byte - in_start] = reg_buf[byte - reg_start]; 70798944Sobrien } 70898944Sobrien } 70998944Sobrien} 71098944Sobrien 71198944Sobrien/* Read register REGNUM into memory at MYADDR, which must be large 71298944Sobrien enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the 71398944Sobrien register is known to be the size of a CORE_ADDR or smaller, 71498944Sobrien read_register can be used instead. */ 71598944Sobrien 71698944Sobrienstatic void 71798944Sobrienlegacy_read_register_gen (int regnum, char *myaddr) 71898944Sobrien{ 71998944Sobrien gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS)); 72098944Sobrien if (! ptid_equal (registers_ptid, inferior_ptid)) 72198944Sobrien { 72298944Sobrien registers_changed (); 72398944Sobrien registers_ptid = inferior_ptid; 72498944Sobrien } 72598944Sobrien 72698944Sobrien if (!register_cached (regnum)) 727130803Smarcel target_fetch_registers (regnum); 72898944Sobrien 729130803Smarcel memcpy (myaddr, register_buffer (current_regcache, regnum), 730130803Smarcel DEPRECATED_REGISTER_RAW_SIZE (regnum)); 73198944Sobrien} 73298944Sobrien 73398944Sobrienvoid 734130803Smarcelregcache_raw_read (struct regcache *regcache, int regnum, void *buf) 73598944Sobrien{ 736130803Smarcel gdb_assert (regcache != NULL && buf != NULL); 737130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 738130803Smarcel if (regcache->descr->legacy_p 739130803Smarcel && !regcache->readonly_p) 740130803Smarcel { 741130803Smarcel gdb_assert (regcache == current_regcache); 742130803Smarcel /* For moment, just use underlying legacy code. Ulgh!!! This 743130803Smarcel silently and very indirectly updates the regcache's regcache 744130803Smarcel via the global deprecated_register_valid[]. */ 745130803Smarcel legacy_read_register_gen (regnum, buf); 746130803Smarcel return; 747130803Smarcel } 748130803Smarcel /* Make certain that the register cache is up-to-date with respect 749130803Smarcel to the current thread. This switching shouldn't be necessary 750130803Smarcel only there is still only one target side register cache. Sigh! 751130803Smarcel On the bright side, at least there is a regcache object. */ 752130803Smarcel if (!regcache->readonly_p) 753130803Smarcel { 754130803Smarcel gdb_assert (regcache == current_regcache); 755130803Smarcel if (! ptid_equal (registers_ptid, inferior_ptid)) 756130803Smarcel { 757130803Smarcel registers_changed (); 758130803Smarcel registers_ptid = inferior_ptid; 759130803Smarcel } 760130803Smarcel if (!register_cached (regnum)) 761130803Smarcel target_fetch_registers (regnum); 762130803Smarcel } 763130803Smarcel /* Copy the value directly into the register cache. */ 764130803Smarcel memcpy (buf, register_buffer (regcache, regnum), 765130803Smarcel regcache->descr->sizeof_register[regnum]); 76698944Sobrien} 76798944Sobrien 76898944Sobrienvoid 769130803Smarcelregcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val) 77098944Sobrien{ 771130803Smarcel char *buf; 772130803Smarcel gdb_assert (regcache != NULL); 773130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 774130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 775130803Smarcel regcache_raw_read (regcache, regnum, buf); 776130803Smarcel (*val) = extract_signed_integer (buf, 777130803Smarcel regcache->descr->sizeof_register[regnum]); 778130803Smarcel} 779130803Smarcel 780130803Smarcelvoid 781130803Smarcelregcache_raw_read_unsigned (struct regcache *regcache, int regnum, 782130803Smarcel ULONGEST *val) 783130803Smarcel{ 784130803Smarcel char *buf; 785130803Smarcel gdb_assert (regcache != NULL); 786130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 787130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 788130803Smarcel regcache_raw_read (regcache, regnum, buf); 789130803Smarcel (*val) = extract_unsigned_integer (buf, 790130803Smarcel regcache->descr->sizeof_register[regnum]); 791130803Smarcel} 792130803Smarcel 793130803Smarcelvoid 794130803Smarcelregcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val) 795130803Smarcel{ 796130803Smarcel void *buf; 797130803Smarcel gdb_assert (regcache != NULL); 798130803Smarcel gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers); 799130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 800130803Smarcel store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val); 801130803Smarcel regcache_raw_write (regcache, regnum, buf); 802130803Smarcel} 803130803Smarcel 804130803Smarcelvoid 805130803Smarcelregcache_raw_write_unsigned (struct regcache *regcache, int regnum, 806130803Smarcel ULONGEST val) 807130803Smarcel{ 808130803Smarcel void *buf; 809130803Smarcel gdb_assert (regcache != NULL); 810130803Smarcel gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers); 811130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 812130803Smarcel store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val); 813130803Smarcel regcache_raw_write (regcache, regnum, buf); 814130803Smarcel} 815130803Smarcel 816130803Smarcelvoid 817130803Smarceldeprecated_read_register_gen (int regnum, char *buf) 818130803Smarcel{ 819130803Smarcel gdb_assert (current_regcache != NULL); 820130803Smarcel gdb_assert (current_regcache->descr->gdbarch == current_gdbarch); 821130803Smarcel if (current_regcache->descr->legacy_p) 82298944Sobrien { 82398944Sobrien legacy_read_register_gen (regnum, buf); 82498944Sobrien return; 82598944Sobrien } 826130803Smarcel regcache_cooked_read (current_regcache, regnum, buf); 82798944Sobrien} 82898944Sobrien 829130803Smarcelvoid 830130803Smarcelregcache_cooked_read (struct regcache *regcache, int regnum, void *buf) 831130803Smarcel{ 832130803Smarcel gdb_assert (regnum >= 0); 833130803Smarcel gdb_assert (regnum < regcache->descr->nr_cooked_registers); 834130803Smarcel if (regnum < regcache->descr->nr_raw_registers) 835130803Smarcel regcache_raw_read (regcache, regnum, buf); 836130803Smarcel else if (regcache->readonly_p 837130803Smarcel && regnum < regcache->descr->nr_cooked_registers 838130803Smarcel && regcache->register_valid_p[regnum]) 839130803Smarcel /* Read-only register cache, perhaphs the cooked value was cached? */ 840130803Smarcel memcpy (buf, register_buffer (regcache, regnum), 841130803Smarcel regcache->descr->sizeof_register[regnum]); 842130803Smarcel else 843130803Smarcel gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache, 844130803Smarcel regnum, buf); 845130803Smarcel} 84698944Sobrien 847130803Smarcelvoid 848130803Smarcelregcache_cooked_read_signed (struct regcache *regcache, int regnum, 849130803Smarcel LONGEST *val) 850130803Smarcel{ 851130803Smarcel char *buf; 852130803Smarcel gdb_assert (regcache != NULL); 853130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers); 854130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 855130803Smarcel regcache_cooked_read (regcache, regnum, buf); 856130803Smarcel (*val) = extract_signed_integer (buf, 857130803Smarcel regcache->descr->sizeof_register[regnum]); 858130803Smarcel} 859130803Smarcel 860130803Smarcelvoid 861130803Smarcelregcache_cooked_read_unsigned (struct regcache *regcache, int regnum, 862130803Smarcel ULONGEST *val) 863130803Smarcel{ 864130803Smarcel char *buf; 865130803Smarcel gdb_assert (regcache != NULL); 866130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers); 867130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 868130803Smarcel regcache_cooked_read (regcache, regnum, buf); 869130803Smarcel (*val) = extract_unsigned_integer (buf, 870130803Smarcel regcache->descr->sizeof_register[regnum]); 871130803Smarcel} 872130803Smarcel 873130803Smarcelvoid 874130803Smarcelregcache_cooked_write_signed (struct regcache *regcache, int regnum, 875130803Smarcel LONGEST val) 876130803Smarcel{ 877130803Smarcel void *buf; 878130803Smarcel gdb_assert (regcache != NULL); 879130803Smarcel gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers); 880130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 881130803Smarcel store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val); 882130803Smarcel regcache_cooked_write (regcache, regnum, buf); 883130803Smarcel} 884130803Smarcel 885130803Smarcelvoid 886130803Smarcelregcache_cooked_write_unsigned (struct regcache *regcache, int regnum, 887130803Smarcel ULONGEST val) 888130803Smarcel{ 889130803Smarcel void *buf; 890130803Smarcel gdb_assert (regcache != NULL); 891130803Smarcel gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers); 892130803Smarcel buf = alloca (regcache->descr->sizeof_register[regnum]); 893130803Smarcel store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val); 894130803Smarcel regcache_cooked_write (regcache, regnum, buf); 895130803Smarcel} 896130803Smarcel 89798944Sobrien/* Write register REGNUM at MYADDR to the target. MYADDR points at 89898944Sobrien REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */ 89998944Sobrien 90098944Sobrienstatic void 901130803Smarcellegacy_write_register_gen (int regnum, const void *myaddr) 90298944Sobrien{ 90398944Sobrien int size; 90498944Sobrien gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS)); 90598944Sobrien 90698944Sobrien /* On the sparc, writing %g0 is a no-op, so we don't even want to 90798944Sobrien change the registers array if something writes to this register. */ 90898944Sobrien if (CANNOT_STORE_REGISTER (regnum)) 90998944Sobrien return; 91098944Sobrien 91198944Sobrien if (! ptid_equal (registers_ptid, inferior_ptid)) 91298944Sobrien { 91398944Sobrien registers_changed (); 91498944Sobrien registers_ptid = inferior_ptid; 91598944Sobrien } 91698944Sobrien 917130803Smarcel size = DEPRECATED_REGISTER_RAW_SIZE (regnum); 91898944Sobrien 91998944Sobrien if (real_register (regnum)) 92098944Sobrien { 92198944Sobrien /* If we have a valid copy of the register, and new value == old 92298944Sobrien value, then don't bother doing the actual store. */ 92398944Sobrien if (register_cached (regnum) 924130803Smarcel && (memcmp (register_buffer (current_regcache, regnum), myaddr, size) 925130803Smarcel == 0)) 92698944Sobrien return; 92798944Sobrien else 92898944Sobrien target_prepare_to_store (); 92998944Sobrien } 93098944Sobrien 931130803Smarcel memcpy (register_buffer (current_regcache, regnum), myaddr, size); 93298944Sobrien 93398944Sobrien set_register_cached (regnum, 1); 934130803Smarcel target_store_registers (regnum); 93598944Sobrien} 93698944Sobrien 93798944Sobrienvoid 938130803Smarcelregcache_raw_write (struct regcache *regcache, int regnum, const void *buf) 93998944Sobrien{ 940130803Smarcel gdb_assert (regcache != NULL && buf != NULL); 941130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 942130803Smarcel gdb_assert (!regcache->readonly_p); 943130803Smarcel 944130803Smarcel if (regcache->descr->legacy_p) 945130803Smarcel { 946130803Smarcel /* For moment, just use underlying legacy code. Ulgh!!! This 947130803Smarcel silently and very indirectly updates the regcache's buffers 948130803Smarcel via the globals deprecated_register_valid[] and registers[]. */ 949130803Smarcel gdb_assert (regcache == current_regcache); 950130803Smarcel legacy_write_register_gen (regnum, buf); 951130803Smarcel return; 952130803Smarcel } 953130803Smarcel 954130803Smarcel /* On the sparc, writing %g0 is a no-op, so we don't even want to 955130803Smarcel change the registers array if something writes to this register. */ 956130803Smarcel if (CANNOT_STORE_REGISTER (regnum)) 957130803Smarcel return; 958130803Smarcel 959130803Smarcel /* Make certain that the correct cache is selected. */ 960130803Smarcel gdb_assert (regcache == current_regcache); 961130803Smarcel if (! ptid_equal (registers_ptid, inferior_ptid)) 962130803Smarcel { 963130803Smarcel registers_changed (); 964130803Smarcel registers_ptid = inferior_ptid; 965130803Smarcel } 966130803Smarcel 967130803Smarcel /* If we have a valid copy of the register, and new value == old 968130803Smarcel value, then don't bother doing the actual store. */ 969130803Smarcel if (regcache_valid_p (regcache, regnum) 970130803Smarcel && (memcmp (register_buffer (regcache, regnum), buf, 971130803Smarcel regcache->descr->sizeof_register[regnum]) == 0)) 972130803Smarcel return; 973130803Smarcel 974130803Smarcel target_prepare_to_store (); 975130803Smarcel memcpy (register_buffer (regcache, regnum), buf, 976130803Smarcel regcache->descr->sizeof_register[regnum]); 977130803Smarcel regcache->register_valid_p[regnum] = 1; 978130803Smarcel target_store_registers (regnum); 97998944Sobrien} 98098944Sobrien 98198944Sobrienvoid 982130803Smarceldeprecated_write_register_gen (int regnum, char *buf) 98398944Sobrien{ 984130803Smarcel gdb_assert (current_regcache != NULL); 985130803Smarcel gdb_assert (current_regcache->descr->gdbarch == current_gdbarch); 986130803Smarcel if (current_regcache->descr->legacy_p) 98798944Sobrien { 98898944Sobrien legacy_write_register_gen (regnum, buf); 98998944Sobrien return; 99098944Sobrien } 991130803Smarcel regcache_cooked_write (current_regcache, regnum, buf); 99298944Sobrien} 99398944Sobrien 994130803Smarcelvoid 995130803Smarcelregcache_cooked_write (struct regcache *regcache, int regnum, const void *buf) 996130803Smarcel{ 997130803Smarcel gdb_assert (regnum >= 0); 998130803Smarcel gdb_assert (regnum < regcache->descr->nr_cooked_registers); 999130803Smarcel if (regnum < regcache->descr->nr_raw_registers) 1000130803Smarcel regcache_raw_write (regcache, regnum, buf); 1001130803Smarcel else 1002130803Smarcel gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache, 1003130803Smarcel regnum, buf); 1004130803Smarcel} 1005130803Smarcel 100698944Sobrien/* Copy INLEN bytes of consecutive data from memory at MYADDR 100798944Sobrien into registers starting with the MYREGSTART'th byte of register data. */ 100898944Sobrien 100998944Sobrienvoid 1010130803Smarceldeprecated_write_register_bytes (int myregstart, char *myaddr, int inlen) 101198944Sobrien{ 101298944Sobrien int myregend = myregstart + inlen; 101398944Sobrien int regnum; 101498944Sobrien 101598944Sobrien target_prepare_to_store (); 101698944Sobrien 101798944Sobrien /* Scan through the registers updating any that are covered by the 101898944Sobrien range myregstart<=>myregend using write_register_gen, which does 101998944Sobrien nice things like handling threads, and avoiding updates when the 102098944Sobrien new and old contents are the same. */ 102198944Sobrien 102298944Sobrien for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) 102398944Sobrien { 102498944Sobrien int regstart, regend; 102598944Sobrien 1026130803Smarcel regstart = DEPRECATED_REGISTER_BYTE (regnum); 1027130803Smarcel regend = regstart + DEPRECATED_REGISTER_RAW_SIZE (regnum); 102898944Sobrien 102998944Sobrien /* Is this register completely outside the range the user is writing? */ 103098944Sobrien if (myregend <= regstart || regend <= myregstart) 103198944Sobrien /* do nothing */ ; 103298944Sobrien 103398944Sobrien /* Is this register completely within the range the user is writing? */ 103498944Sobrien else if (myregstart <= regstart && regend <= myregend) 1035130803Smarcel deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart)); 103698944Sobrien 103798944Sobrien /* The register partially overlaps the range being written. */ 103898944Sobrien else 103998944Sobrien { 1040130803Smarcel char regbuf[MAX_REGISTER_SIZE]; 104198944Sobrien /* What's the overlap between this register's bytes and 104298944Sobrien those the caller wants to write? */ 104398944Sobrien int overlapstart = max (regstart, myregstart); 104498944Sobrien int overlapend = min (regend, myregend); 104598944Sobrien 104698944Sobrien /* We may be doing a partial update of an invalid register. 104798944Sobrien Update it from the target before scribbling on it. */ 1048130803Smarcel deprecated_read_register_gen (regnum, regbuf); 104998944Sobrien 1050130803Smarcel memcpy (&deprecated_registers[overlapstart], 105198944Sobrien myaddr + (overlapstart - myregstart), 105298944Sobrien overlapend - overlapstart); 105398944Sobrien 1054130803Smarcel target_store_registers (regnum); 105598944Sobrien } 105698944Sobrien } 105798944Sobrien} 105898944Sobrien 1059130803Smarcel/* Perform a partial register transfer using a read, modify, write 1060130803Smarcel operation. */ 106198944Sobrien 1062130803Smarceltypedef void (regcache_read_ftype) (struct regcache *regcache, int regnum, 1063130803Smarcel void *buf); 1064130803Smarceltypedef void (regcache_write_ftype) (struct regcache *regcache, int regnum, 1065130803Smarcel const void *buf); 106698944Sobrien 1067130803Smarcelstatic void 1068130803Smarcelregcache_xfer_part (struct regcache *regcache, int regnum, 1069130803Smarcel int offset, int len, void *in, const void *out, 1070130803Smarcel regcache_read_ftype *read, regcache_write_ftype *write) 107198944Sobrien{ 1072130803Smarcel struct regcache_descr *descr = regcache->descr; 1073130803Smarcel bfd_byte reg[MAX_REGISTER_SIZE]; 1074130803Smarcel gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]); 1075130803Smarcel gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]); 1076130803Smarcel /* Something to do? */ 1077130803Smarcel if (offset + len == 0) 1078130803Smarcel return; 1079130803Smarcel /* Read (when needed) ... */ 1080130803Smarcel if (in != NULL 1081130803Smarcel || offset > 0 1082130803Smarcel || offset + len < descr->sizeof_register[regnum]) 1083130803Smarcel { 1084130803Smarcel gdb_assert (read != NULL); 1085130803Smarcel read (regcache, regnum, reg); 1086130803Smarcel } 1087130803Smarcel /* ... modify ... */ 1088130803Smarcel if (in != NULL) 1089130803Smarcel memcpy (in, reg + offset, len); 1090130803Smarcel if (out != NULL) 1091130803Smarcel memcpy (reg + offset, out, len); 1092130803Smarcel /* ... write (when needed). */ 1093130803Smarcel if (out != NULL) 1094130803Smarcel { 1095130803Smarcel gdb_assert (write != NULL); 1096130803Smarcel write (regcache, regnum, reg); 1097130803Smarcel } 109898944Sobrien} 109998944Sobrien 1100130803Smarcelvoid 1101130803Smarcelregcache_raw_read_part (struct regcache *regcache, int regnum, 1102130803Smarcel int offset, int len, void *buf) 110398944Sobrien{ 1104130803Smarcel struct regcache_descr *descr = regcache->descr; 1105130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers); 1106130803Smarcel regcache_xfer_part (regcache, regnum, offset, len, buf, NULL, 1107130803Smarcel regcache_raw_read, regcache_raw_write); 1108130803Smarcel} 110998944Sobrien 1110130803Smarcelvoid 1111130803Smarcelregcache_raw_write_part (struct regcache *regcache, int regnum, 1112130803Smarcel int offset, int len, const void *buf) 1113130803Smarcel{ 1114130803Smarcel struct regcache_descr *descr = regcache->descr; 1115130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers); 1116130803Smarcel regcache_xfer_part (regcache, regnum, offset, len, NULL, buf, 1117130803Smarcel regcache_raw_read, regcache_raw_write); 1118130803Smarcel} 111998944Sobrien 1120130803Smarcelvoid 1121130803Smarcelregcache_cooked_read_part (struct regcache *regcache, int regnum, 1122130803Smarcel int offset, int len, void *buf) 1123130803Smarcel{ 1124130803Smarcel struct regcache_descr *descr = regcache->descr; 1125130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers); 1126130803Smarcel regcache_xfer_part (regcache, regnum, offset, len, buf, NULL, 1127130803Smarcel regcache_cooked_read, regcache_cooked_write); 1128130803Smarcel} 112998944Sobrien 1130130803Smarcelvoid 1131130803Smarcelregcache_cooked_write_part (struct regcache *regcache, int regnum, 1132130803Smarcel int offset, int len, const void *buf) 1133130803Smarcel{ 1134130803Smarcel struct regcache_descr *descr = regcache->descr; 1135130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers); 1136130803Smarcel regcache_xfer_part (regcache, regnum, offset, len, NULL, buf, 1137130803Smarcel regcache_cooked_read, regcache_cooked_write); 1138130803Smarcel} 113998944Sobrien 1140130803Smarcel/* Hack to keep code that view the register buffer as raw bytes 1141130803Smarcel working. */ 114298944Sobrien 1143130803Smarcelint 1144130803Smarcelregister_offset_hack (struct gdbarch *gdbarch, int regnum) 1145130803Smarcel{ 1146130803Smarcel struct regcache_descr *descr = regcache_descr (gdbarch); 1147130803Smarcel gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers); 1148130803Smarcel return descr->register_offset[regnum]; 114998944Sobrien} 115098944Sobrien 1151130803Smarcel/* Return the contents of register REGNUM as an unsigned integer. */ 115298944Sobrien 1153130803SmarcelULONGEST 1154130803Smarcelread_register (int regnum) 115598944Sobrien{ 1156130803Smarcel char *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum)); 1157130803Smarcel deprecated_read_register_gen (regnum, buf); 1158130803Smarcel return (extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum))); 115998944Sobrien} 116098944Sobrien 1161130803SmarcelULONGEST 1162130803Smarcelread_register_pid (int regnum, ptid_t ptid) 116398944Sobrien{ 116498944Sobrien ptid_t save_ptid; 1165130803Smarcel int save_pid; 1166130803Smarcel CORE_ADDR retval; 116798944Sobrien 116898944Sobrien if (ptid_equal (ptid, inferior_ptid)) 1169130803Smarcel return read_register (regnum); 117098944Sobrien 117198944Sobrien save_ptid = inferior_ptid; 117298944Sobrien 117398944Sobrien inferior_ptid = ptid; 117498944Sobrien 1175130803Smarcel retval = read_register (regnum); 117698944Sobrien 117798944Sobrien inferior_ptid = save_ptid; 117898944Sobrien 117998944Sobrien return retval; 118098944Sobrien} 118198944Sobrien 118298944Sobrien/* Store VALUE into the raw contents of register number REGNUM. */ 118398944Sobrien 118498944Sobrienvoid 118598944Sobrienwrite_register (int regnum, LONGEST val) 118698944Sobrien{ 118798944Sobrien void *buf; 118898944Sobrien int size; 1189130803Smarcel size = DEPRECATED_REGISTER_RAW_SIZE (regnum); 119098944Sobrien buf = alloca (size); 119198944Sobrien store_signed_integer (buf, size, (LONGEST) val); 1192130803Smarcel deprecated_write_register_gen (regnum, buf); 119398944Sobrien} 119498944Sobrien 119598944Sobrienvoid 119698944Sobrienwrite_register_pid (int regnum, CORE_ADDR val, ptid_t ptid) 119798944Sobrien{ 119898944Sobrien ptid_t save_ptid; 119998944Sobrien 120098944Sobrien if (ptid_equal (ptid, inferior_ptid)) 120198944Sobrien { 120298944Sobrien write_register (regnum, val); 120398944Sobrien return; 120498944Sobrien } 120598944Sobrien 120698944Sobrien save_ptid = inferior_ptid; 120798944Sobrien 120898944Sobrien inferior_ptid = ptid; 120998944Sobrien 121098944Sobrien write_register (regnum, val); 121198944Sobrien 121298944Sobrien inferior_ptid = save_ptid; 121398944Sobrien} 121498944Sobrien 1215130803Smarcel/* FIXME: kettenis/20030828: We should get rid of supply_register and 1216130803Smarcel regcache_collect in favour of regcache_raw_supply and 1217130803Smarcel regcache_raw_collect. */ 1218130803Smarcel 121998944Sobrien/* SUPPLY_REGISTER() 122098944Sobrien 122198944Sobrien Record that register REGNUM contains VAL. This is used when the 122298944Sobrien value is obtained from the inferior or core dump, so there is no 122398944Sobrien need to store the value there. 122498944Sobrien 122598944Sobrien If VAL is a NULL pointer, then it's probably an unsupported register. 122698944Sobrien We just set its value to all zeros. We might want to record this 122798944Sobrien fact, and report it to the users of read_register and friends. */ 122898944Sobrien 122998944Sobrienvoid 1230130803Smarcelsupply_register (int regnum, const void *val) 123198944Sobrien{ 1232130803Smarcel regcache_raw_supply (current_regcache, regnum, val); 123398944Sobrien 123498944Sobrien /* On some architectures, e.g. HPPA, there are a few stray bits in 123598944Sobrien some registers, that the rest of the code would like to ignore. */ 123698944Sobrien 123798944Sobrien /* NOTE: cagney/2001-03-16: The macro CLEAN_UP_REGISTER_VALUE is 123898944Sobrien going to be deprecated. Instead architectures will leave the raw 123998944Sobrien register value as is and instead clean things up as they pass 1240130803Smarcel through the method gdbarch_pseudo_register_read() clean up the 124198944Sobrien values. */ 124298944Sobrien 124398944Sobrien#ifdef DEPRECATED_CLEAN_UP_REGISTER_VALUE 1244130803Smarcel DEPRECATED_CLEAN_UP_REGISTER_VALUE \ 1245130803Smarcel (regnum, register_buffer (current_regcache, regnum)); 124698944Sobrien#endif 124798944Sobrien} 124898944Sobrien 124998944Sobrienvoid 125098944Sobrienregcache_collect (int regnum, void *buf) 125198944Sobrien{ 1252130803Smarcel regcache_raw_collect (current_regcache, regnum, buf); 125398944Sobrien} 125498944Sobrien 1255130803Smarcel/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */ 125698944Sobrien 1257130803Smarcelvoid 1258130803Smarcelregcache_raw_supply (struct regcache *regcache, int regnum, const void *buf) 1259130803Smarcel{ 1260130803Smarcel void *regbuf; 1261130803Smarcel size_t size; 126298944Sobrien 1263130803Smarcel gdb_assert (regcache != NULL); 1264130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 1265130803Smarcel gdb_assert (!regcache->readonly_p); 126698944Sobrien 1267130803Smarcel /* FIXME: kettenis/20030828: It shouldn't be necessary to handle 1268130803Smarcel CURRENT_REGCACHE specially here. */ 1269130803Smarcel if (regcache == current_regcache 1270130803Smarcel && !ptid_equal (registers_ptid, inferior_ptid)) 1271130803Smarcel { 1272130803Smarcel registers_changed (); 1273130803Smarcel registers_ptid = inferior_ptid; 1274130803Smarcel } 127598944Sobrien 1276130803Smarcel regbuf = register_buffer (regcache, regnum); 1277130803Smarcel size = regcache->descr->sizeof_register[regnum]; 127898944Sobrien 1279130803Smarcel if (buf) 1280130803Smarcel memcpy (regbuf, buf, size); 1281130803Smarcel else 1282130803Smarcel memset (regbuf, 0, size); 128398944Sobrien 1284130803Smarcel /* Mark the register as cached. */ 1285130803Smarcel regcache->register_valid_p[regnum] = 1; 1286130803Smarcel} 1287130803Smarcel 1288130803Smarcel/* Collect register REGNUM from REGCACHE and store its contents in BUF. */ 1289130803Smarcel 1290130803Smarcelvoid 1291130803Smarcelregcache_raw_collect (const struct regcache *regcache, int regnum, void *buf) 129298944Sobrien{ 1293130803Smarcel const void *regbuf; 1294130803Smarcel size_t size; 1295130803Smarcel 1296130803Smarcel gdb_assert (regcache != NULL && buf != NULL); 1297130803Smarcel gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); 1298130803Smarcel 1299130803Smarcel regbuf = register_buffer (regcache, regnum); 1300130803Smarcel size = regcache->descr->sizeof_register[regnum]; 1301130803Smarcel memcpy (buf, regbuf, size); 130298944Sobrien} 130398944Sobrien 1304130803Smarcel 1305130803Smarcel/* read_pc, write_pc, read_sp, deprecated_read_fp, etc. Special 1306130803Smarcel handling for registers PC, SP, and FP. */ 1307130803Smarcel 1308130803Smarcel/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(), 1309130803Smarcel read_sp(), and deprecated_read_fp(), will eventually be replaced by 1310130803Smarcel per-frame methods. Instead of relying on the global INFERIOR_PTID, 1311130803Smarcel they will use the contextual information provided by the FRAME. 1312130803Smarcel These functions do not belong in the register cache. */ 1313130803Smarcel 1314130803Smarcel/* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(), 1315130803Smarcel write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to 1316130803Smarcel be replaced by something that does not rely on global state. But 1317130803Smarcel what? */ 1318130803Smarcel 131998944SobrienCORE_ADDR 132098944Sobrienread_pc_pid (ptid_t ptid) 132198944Sobrien{ 132298944Sobrien ptid_t saved_inferior_ptid; 132398944Sobrien CORE_ADDR pc_val; 132498944Sobrien 132598944Sobrien /* In case ptid != inferior_ptid. */ 132698944Sobrien saved_inferior_ptid = inferior_ptid; 132798944Sobrien inferior_ptid = ptid; 132898944Sobrien 1329130803Smarcel if (TARGET_READ_PC_P ()) 1330130803Smarcel pc_val = TARGET_READ_PC (ptid); 1331130803Smarcel /* Else use per-frame method on get_current_frame. */ 1332130803Smarcel else if (PC_REGNUM >= 0) 1333130803Smarcel { 1334130803Smarcel CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid); 1335130803Smarcel pc_val = ADDR_BITS_REMOVE (raw_val); 1336130803Smarcel } 1337130803Smarcel else 1338130803Smarcel internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC"); 133998944Sobrien 134098944Sobrien inferior_ptid = saved_inferior_ptid; 134198944Sobrien return pc_val; 134298944Sobrien} 134398944Sobrien 134498944SobrienCORE_ADDR 134598944Sobrienread_pc (void) 134698944Sobrien{ 134798944Sobrien return read_pc_pid (inferior_ptid); 134898944Sobrien} 134998944Sobrien 135098944Sobrienvoid 135198944Sobriengeneric_target_write_pc (CORE_ADDR pc, ptid_t ptid) 135298944Sobrien{ 135398944Sobrien if (PC_REGNUM >= 0) 135498944Sobrien write_register_pid (PC_REGNUM, pc, ptid); 1355130803Smarcel else 1356130803Smarcel internal_error (__FILE__, __LINE__, 1357130803Smarcel "generic_target_write_pc"); 135898944Sobrien} 135998944Sobrien 136098944Sobrienvoid 136198944Sobrienwrite_pc_pid (CORE_ADDR pc, ptid_t ptid) 136298944Sobrien{ 136398944Sobrien ptid_t saved_inferior_ptid; 136498944Sobrien 136598944Sobrien /* In case ptid != inferior_ptid. */ 136698944Sobrien saved_inferior_ptid = inferior_ptid; 136798944Sobrien inferior_ptid = ptid; 136898944Sobrien 136998944Sobrien TARGET_WRITE_PC (pc, ptid); 137098944Sobrien 137198944Sobrien inferior_ptid = saved_inferior_ptid; 137298944Sobrien} 137398944Sobrien 137498944Sobrienvoid 137598944Sobrienwrite_pc (CORE_ADDR pc) 137698944Sobrien{ 137798944Sobrien write_pc_pid (pc, inferior_ptid); 137898944Sobrien} 137998944Sobrien 138098944Sobrien/* Cope with strage ways of getting to the stack and frame pointers */ 138198944Sobrien 138298944SobrienCORE_ADDR 1383130803Smarcelread_sp (void) 138498944Sobrien{ 1385130803Smarcel if (TARGET_READ_SP_P ()) 1386130803Smarcel return TARGET_READ_SP (); 1387130803Smarcel else if (gdbarch_unwind_sp_p (current_gdbarch)) 1388130803Smarcel return get_frame_sp (get_current_frame ()); 1389130803Smarcel else if (SP_REGNUM >= 0) 1390130803Smarcel /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions 1391130803Smarcel about the architecture so put it at the end. */ 139298944Sobrien return read_register (SP_REGNUM); 1393130803Smarcel internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP"); 139498944Sobrien} 139598944Sobrien 1396130803Smarcelvoid 1397130803Smarceldeprecated_write_sp (CORE_ADDR val) 1398130803Smarcel{ 1399130803Smarcel gdb_assert (SP_REGNUM >= 0); 1400130803Smarcel write_register (SP_REGNUM, val); 1401130803Smarcel} 1402130803Smarcel 140398944SobrienCORE_ADDR 1404130803Smarceldeprecated_read_fp (void) 140598944Sobrien{ 1406130803Smarcel if (DEPRECATED_TARGET_READ_FP_P ()) 1407130803Smarcel return DEPRECATED_TARGET_READ_FP (); 1408130803Smarcel else if (DEPRECATED_FP_REGNUM >= 0) 1409130803Smarcel return read_register (DEPRECATED_FP_REGNUM); 1410130803Smarcel else 1411130803Smarcel internal_error (__FILE__, __LINE__, "deprecated_read_fp"); 141298944Sobrien} 141398944Sobrien 1414130803Smarcelstatic void 1415130803Smarcelreg_flush_command (char *command, int from_tty) 141698944Sobrien{ 1417130803Smarcel /* Force-flush the register cache. */ 1418130803Smarcel registers_changed (); 1419130803Smarcel if (from_tty) 1420130803Smarcel printf_filtered ("Register cache flushed.\n"); 1421130803Smarcel} 1422130803Smarcel 1423130803Smarcelstatic void 1424130803Smarcelbuild_regcache (void) 1425130803Smarcel{ 1426130803Smarcel current_regcache = regcache_xmalloc (current_gdbarch); 1427130803Smarcel current_regcache->readonly_p = 0; 1428130803Smarcel deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache); 1429130803Smarcel deprecated_register_valid = current_regcache->register_valid_p; 1430130803Smarcel} 1431130803Smarcel 1432130803Smarcelstatic void 1433130803Smarceldump_endian_bytes (struct ui_file *file, enum bfd_endian endian, 1434130803Smarcel const unsigned char *buf, long len) 1435130803Smarcel{ 1436130803Smarcel int i; 1437130803Smarcel switch (endian) 143898944Sobrien { 1439130803Smarcel case BFD_ENDIAN_BIG: 1440130803Smarcel for (i = 0; i < len; i++) 1441130803Smarcel fprintf_unfiltered (file, "%02x", buf[i]); 1442130803Smarcel break; 1443130803Smarcel case BFD_ENDIAN_LITTLE: 1444130803Smarcel for (i = len - 1; i >= 0; i--) 1445130803Smarcel fprintf_unfiltered (file, "%02x", buf[i]); 1446130803Smarcel break; 1447130803Smarcel default: 1448130803Smarcel internal_error (__FILE__, __LINE__, "Bad switch"); 144998944Sobrien } 145098944Sobrien} 145198944Sobrien 1452130803Smarcelenum regcache_dump_what 145398944Sobrien{ 1454130803Smarcel regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups 1455130803Smarcel}; 145698944Sobrien 1457130803Smarcelstatic void 1458130803Smarcelregcache_dump (struct regcache *regcache, struct ui_file *file, 1459130803Smarcel enum regcache_dump_what what_to_dump) 146098944Sobrien{ 1461130803Smarcel struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); 1462130803Smarcel struct gdbarch *gdbarch = regcache->descr->gdbarch; 1463130803Smarcel int regnum; 1464130803Smarcel int footnote_nr = 0; 1465130803Smarcel int footnote_register_size = 0; 1466130803Smarcel int footnote_register_offset = 0; 1467130803Smarcel int footnote_register_type_name_null = 0; 1468130803Smarcel long register_offset = 0; 1469130803Smarcel unsigned char buf[MAX_REGISTER_SIZE]; 1470130803Smarcel 1471130803Smarcel#if 0 1472130803Smarcel fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p); 1473130803Smarcel fprintf_unfiltered (file, "nr_raw_registers %d\n", 1474130803Smarcel regcache->descr->nr_raw_registers); 1475130803Smarcel fprintf_unfiltered (file, "nr_cooked_registers %d\n", 1476130803Smarcel regcache->descr->nr_cooked_registers); 1477130803Smarcel fprintf_unfiltered (file, "sizeof_raw_registers %ld\n", 1478130803Smarcel regcache->descr->sizeof_raw_registers); 1479130803Smarcel fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n", 1480130803Smarcel regcache->descr->sizeof_raw_register_valid_p); 1481130803Smarcel fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS); 1482130803Smarcel fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS); 148398944Sobrien#endif 148498944Sobrien 1485130803Smarcel gdb_assert (regcache->descr->nr_cooked_registers 1486130803Smarcel == (NUM_REGS + NUM_PSEUDO_REGS)); 1487130803Smarcel 1488130803Smarcel for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++) 1489130803Smarcel { 1490130803Smarcel /* Name. */ 1491130803Smarcel if (regnum < 0) 1492130803Smarcel fprintf_unfiltered (file, " %-10s", "Name"); 1493130803Smarcel else 1494130803Smarcel { 1495130803Smarcel const char *p = REGISTER_NAME (regnum); 1496130803Smarcel if (p == NULL) 1497130803Smarcel p = ""; 1498130803Smarcel else if (p[0] == '\0') 1499130803Smarcel p = "''"; 1500130803Smarcel fprintf_unfiltered (file, " %-10s", p); 1501130803Smarcel } 1502130803Smarcel 1503130803Smarcel /* Number. */ 1504130803Smarcel if (regnum < 0) 1505130803Smarcel fprintf_unfiltered (file, " %4s", "Nr"); 1506130803Smarcel else 1507130803Smarcel fprintf_unfiltered (file, " %4d", regnum); 1508130803Smarcel 1509130803Smarcel /* Relative number. */ 1510130803Smarcel if (regnum < 0) 1511130803Smarcel fprintf_unfiltered (file, " %4s", "Rel"); 1512130803Smarcel else if (regnum < NUM_REGS) 1513130803Smarcel fprintf_unfiltered (file, " %4d", regnum); 1514130803Smarcel else 1515130803Smarcel fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS)); 1516130803Smarcel 1517130803Smarcel /* Offset. */ 1518130803Smarcel if (regnum < 0) 1519130803Smarcel fprintf_unfiltered (file, " %6s ", "Offset"); 1520130803Smarcel else 1521130803Smarcel { 1522130803Smarcel fprintf_unfiltered (file, " %6ld", 1523130803Smarcel regcache->descr->register_offset[regnum]); 1524130803Smarcel if (register_offset != regcache->descr->register_offset[regnum] 1525130803Smarcel || register_offset != DEPRECATED_REGISTER_BYTE (regnum) 1526130803Smarcel || (regnum > 0 1527130803Smarcel && (regcache->descr->register_offset[regnum] 1528130803Smarcel != (regcache->descr->register_offset[regnum - 1] 1529130803Smarcel + regcache->descr->sizeof_register[regnum - 1]))) 1530130803Smarcel ) 1531130803Smarcel { 1532130803Smarcel if (!footnote_register_offset) 1533130803Smarcel footnote_register_offset = ++footnote_nr; 1534130803Smarcel fprintf_unfiltered (file, "*%d", footnote_register_offset); 1535130803Smarcel } 1536130803Smarcel else 1537130803Smarcel fprintf_unfiltered (file, " "); 1538130803Smarcel register_offset = (regcache->descr->register_offset[regnum] 1539130803Smarcel + regcache->descr->sizeof_register[regnum]); 1540130803Smarcel } 1541130803Smarcel 1542130803Smarcel /* Size. */ 1543130803Smarcel if (regnum < 0) 1544130803Smarcel fprintf_unfiltered (file, " %5s ", "Size"); 1545130803Smarcel else 1546130803Smarcel { 1547130803Smarcel fprintf_unfiltered (file, " %5ld", 1548130803Smarcel regcache->descr->sizeof_register[regnum]); 1549130803Smarcel if ((regcache->descr->sizeof_register[regnum] 1550130803Smarcel != DEPRECATED_REGISTER_RAW_SIZE (regnum)) 1551130803Smarcel || (regcache->descr->sizeof_register[regnum] 1552130803Smarcel != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) 1553130803Smarcel || (regcache->descr->sizeof_register[regnum] 1554130803Smarcel != TYPE_LENGTH (register_type (regcache->descr->gdbarch, 1555130803Smarcel regnum))) 1556130803Smarcel ) 1557130803Smarcel { 1558130803Smarcel if (!footnote_register_size) 1559130803Smarcel footnote_register_size = ++footnote_nr; 1560130803Smarcel fprintf_unfiltered (file, "*%d", footnote_register_size); 1561130803Smarcel } 1562130803Smarcel else 1563130803Smarcel fprintf_unfiltered (file, " "); 1564130803Smarcel } 1565130803Smarcel 1566130803Smarcel /* Type. */ 1567130803Smarcel { 1568130803Smarcel const char *t; 1569130803Smarcel if (regnum < 0) 1570130803Smarcel t = "Type"; 1571130803Smarcel else 1572130803Smarcel { 1573130803Smarcel static const char blt[] = "builtin_type"; 1574130803Smarcel t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum)); 1575130803Smarcel if (t == NULL) 1576130803Smarcel { 1577130803Smarcel char *n; 1578130803Smarcel if (!footnote_register_type_name_null) 1579130803Smarcel footnote_register_type_name_null = ++footnote_nr; 1580130803Smarcel xasprintf (&n, "*%d", footnote_register_type_name_null); 1581130803Smarcel make_cleanup (xfree, n); 1582130803Smarcel t = n; 1583130803Smarcel } 1584130803Smarcel /* Chop a leading builtin_type. */ 1585130803Smarcel if (strncmp (t, blt, strlen (blt)) == 0) 1586130803Smarcel t += strlen (blt); 1587130803Smarcel } 1588130803Smarcel fprintf_unfiltered (file, " %-15s", t); 1589130803Smarcel } 1590130803Smarcel 1591130803Smarcel /* Leading space always present. */ 1592130803Smarcel fprintf_unfiltered (file, " "); 1593130803Smarcel 1594130803Smarcel /* Value, raw. */ 1595130803Smarcel if (what_to_dump == regcache_dump_raw) 1596130803Smarcel { 1597130803Smarcel if (regnum < 0) 1598130803Smarcel fprintf_unfiltered (file, "Raw value"); 1599130803Smarcel else if (regnum >= regcache->descr->nr_raw_registers) 1600130803Smarcel fprintf_unfiltered (file, "<cooked>"); 1601130803Smarcel else if (!regcache_valid_p (regcache, regnum)) 1602130803Smarcel fprintf_unfiltered (file, "<invalid>"); 1603130803Smarcel else 1604130803Smarcel { 1605130803Smarcel regcache_raw_read (regcache, regnum, buf); 1606130803Smarcel fprintf_unfiltered (file, "0x"); 1607130803Smarcel dump_endian_bytes (file, TARGET_BYTE_ORDER, buf, 1608130803Smarcel DEPRECATED_REGISTER_RAW_SIZE (regnum)); 1609130803Smarcel } 1610130803Smarcel } 1611130803Smarcel 1612130803Smarcel /* Value, cooked. */ 1613130803Smarcel if (what_to_dump == regcache_dump_cooked) 1614130803Smarcel { 1615130803Smarcel if (regnum < 0) 1616130803Smarcel fprintf_unfiltered (file, "Cooked value"); 1617130803Smarcel else 1618130803Smarcel { 1619130803Smarcel regcache_cooked_read (regcache, regnum, buf); 1620130803Smarcel fprintf_unfiltered (file, "0x"); 1621130803Smarcel dump_endian_bytes (file, TARGET_BYTE_ORDER, buf, 1622130803Smarcel DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); 1623130803Smarcel } 1624130803Smarcel } 1625130803Smarcel 1626130803Smarcel /* Group members. */ 1627130803Smarcel if (what_to_dump == regcache_dump_groups) 1628130803Smarcel { 1629130803Smarcel if (regnum < 0) 1630130803Smarcel fprintf_unfiltered (file, "Groups"); 1631130803Smarcel else 1632130803Smarcel { 1633130803Smarcel const char *sep = ""; 1634130803Smarcel struct reggroup *group; 1635130803Smarcel for (group = reggroup_next (gdbarch, NULL); 1636130803Smarcel group != NULL; 1637130803Smarcel group = reggroup_next (gdbarch, group)) 1638130803Smarcel { 1639130803Smarcel if (gdbarch_register_reggroup_p (gdbarch, regnum, group)) 1640130803Smarcel { 1641130803Smarcel fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group)); 1642130803Smarcel sep = ","; 1643130803Smarcel } 1644130803Smarcel } 1645130803Smarcel } 1646130803Smarcel } 1647130803Smarcel 1648130803Smarcel fprintf_unfiltered (file, "\n"); 1649130803Smarcel } 1650130803Smarcel 1651130803Smarcel if (footnote_register_size) 1652130803Smarcel fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n", 1653130803Smarcel footnote_register_size); 1654130803Smarcel if (footnote_register_offset) 1655130803Smarcel fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n", 1656130803Smarcel footnote_register_offset); 1657130803Smarcel if (footnote_register_type_name_null) 1658130803Smarcel fprintf_unfiltered (file, 1659130803Smarcel "*%d: Register type's name NULL.\n", 1660130803Smarcel footnote_register_type_name_null); 1661130803Smarcel do_cleanups (cleanups); 166298944Sobrien} 166398944Sobrien 1664130803Smarcelstatic void 1665130803Smarcelregcache_print (char *args, enum regcache_dump_what what_to_dump) 166698944Sobrien{ 1667130803Smarcel if (args == NULL) 1668130803Smarcel regcache_dump (current_regcache, gdb_stdout, what_to_dump); 1669130803Smarcel else 167098944Sobrien { 1671130803Smarcel struct ui_file *file = gdb_fopen (args, "w"); 1672130803Smarcel if (file == NULL) 1673130803Smarcel perror_with_name ("maintenance print architecture"); 1674130803Smarcel regcache_dump (current_regcache, file, what_to_dump); 1675130803Smarcel ui_file_delete (file); 167698944Sobrien } 167798944Sobrien} 167898944Sobrien 1679130803Smarcelstatic void 1680130803Smarcelmaintenance_print_registers (char *args, int from_tty) 168198944Sobrien{ 1682130803Smarcel regcache_print (args, regcache_dump_none); 168398944Sobrien} 168498944Sobrien 168598944Sobrienstatic void 1686130803Smarcelmaintenance_print_raw_registers (char *args, int from_tty) 168798944Sobrien{ 1688130803Smarcel regcache_print (args, regcache_dump_raw); 168998944Sobrien} 169098944Sobrien 169198944Sobrienstatic void 1692130803Smarcelmaintenance_print_cooked_registers (char *args, int from_tty) 169398944Sobrien{ 1694130803Smarcel regcache_print (args, regcache_dump_cooked); 169598944Sobrien} 169698944Sobrien 1697130803Smarcelstatic void 1698130803Smarcelmaintenance_print_register_groups (char *args, int from_tty) 1699130803Smarcel{ 1700130803Smarcel regcache_print (args, regcache_dump_groups); 1701130803Smarcel} 1702130803Smarcel 1703130803Smarcelextern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */ 1704130803Smarcel 170598944Sobrienvoid 170698944Sobrien_initialize_regcache (void) 170798944Sobrien{ 1708130803Smarcel regcache_descr_handle = register_gdbarch_data (init_regcache_descr); 1709130803Smarcel DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache); 1710130803Smarcel DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers); 1711130803Smarcel DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid); 1712130803Smarcel deprecated_register_gdbarch_swap (NULL, 0, build_regcache); 171398944Sobrien 171498944Sobrien add_com ("flushregs", class_maintenance, reg_flush_command, 171598944Sobrien "Force gdb to flush its register cache (maintainer command)"); 171698944Sobrien 171798944Sobrien /* Initialize the thread/process associated with the current set of 171898944Sobrien registers. For now, -1 is special, and means `no current process'. */ 171998944Sobrien registers_ptid = pid_to_ptid (-1); 1720130803Smarcel 1721130803Smarcel add_cmd ("registers", class_maintenance, 1722130803Smarcel maintenance_print_registers, 1723130803Smarcel "Print the internal register configuration.\ 1724130803SmarcelTakes an optional file parameter.", 1725130803Smarcel &maintenanceprintlist); 1726130803Smarcel add_cmd ("raw-registers", class_maintenance, 1727130803Smarcel maintenance_print_raw_registers, 1728130803Smarcel "Print the internal register configuration including raw values.\ 1729130803SmarcelTakes an optional file parameter.", 1730130803Smarcel &maintenanceprintlist); 1731130803Smarcel add_cmd ("cooked-registers", class_maintenance, 1732130803Smarcel maintenance_print_cooked_registers, 1733130803Smarcel "Print the internal register configuration including cooked values.\ 1734130803SmarcelTakes an optional file parameter.", 1735130803Smarcel &maintenanceprintlist); 1736130803Smarcel add_cmd ("register-groups", class_maintenance, 1737130803Smarcel maintenance_print_register_groups, 1738130803Smarcel "Print the internal register configuration including each register's group.\ 1739130803SmarcelTakes an optional file parameter.", 1740130803Smarcel &maintenanceprintlist); 1741130803Smarcel 174298944Sobrien} 1743