gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
   4    2001, 2002, 2004 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   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., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbarch.h"
  27 #include "gdbcmd.h"
  28 #include "regcache.h"
  29 #include "reggroups.h"
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include "gdbcmd.h"             /* For maintenanceprintlist.  */
  33 #include "observer.h"
  34
  35 /*
  36  * DATA STRUCTURE
  37  *
  38  * Here is the actual register cache.
  39  */
  40
  41 /* Per-architecture object describing the layout of a register cache.
  42    Computed once when the architecture is created */
  43
  44 struct gdbarch_data *regcache_descr_handle;
  45
  46 struct regcache_descr
  47 {
  48   /* The architecture this descriptor belongs to.  */
  49   struct gdbarch *gdbarch;
  50
  51   /* The raw register cache.  Each raw (or hard) register is supplied
  52      by the target interface.  The raw cache should not contain
  53      redundant information - if the PC is constructed from two
  54      registers then those regigisters and not the PC lives in the raw
  55      cache.  */
  56   int nr_raw_registers;
  57   long sizeof_raw_registers;
  58   long sizeof_raw_register_valid_p;
  59
  60   /* The cooked register space.  Each cooked register in the range
  61      [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
  62      register.  The remaining [NR_RAW_REGISTERS
  63      .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
  64      both raw registers and memory by the architecture methods
  65      gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
  66   int nr_cooked_registers;
  67   long sizeof_cooked_registers;
  68   long sizeof_cooked_register_valid_p;
  69
  70   /* Offset and size (in 8 bit bytes), of reach register in the
  71      register cache.  All registers (including those in the range
  72      [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
  73      Assigning all registers an offset makes it possible to keep
  74      legacy code, such as that found in read_register_bytes() and
  75      write_register_bytes() working.  */
  76   long *register_offset;
  77   long *sizeof_register;
  78
  79   /* Cached table containing the type of each register.  */
  80   struct type **register_type;
  81 };
  82
  83 static void *
  84 init_regcache_descr (struct gdbarch *gdbarch)
  85 {
  86   int i;
  87   struct regcache_descr *descr;
  88   gdb_assert (gdbarch != NULL);
  89
  90   /* Create an initial, zero filled, table.  */
  91   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  92   descr->gdbarch = gdbarch;
  93
  94   /* Total size of the register space.  The raw registers are mapped
  95      directly onto the raw register cache while the pseudo's are
  96      either mapped onto raw-registers or memory.  */
  97   descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
  98   descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
  99
 100   /* Fill in a table of register types.  */
 101   descr->register_type
 102     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
 103   for (i = 0; i < descr->nr_cooked_registers; i++)
 104     descr->register_type[i] = gdbarch_register_type (gdbarch, i);
 105
 106   /* Construct a strictly RAW register cache.  Don't allow pseudo's
 107      into the register cache.  */
 108   descr->nr_raw_registers = NUM_REGS;
 109
 110   /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
 111      array.  This pretects GDB from erant code that accesses elements
 112      of the global register_valid_p[] array in the range [NUM_REGS
 113      .. NUM_REGS + NUM_PSEUDO_REGS).  */
 114   descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
 115
 116   /* Lay out the register cache.
 117
 118      NOTE: cagney/2002-05-22: Only register_type() is used when
 119      constructing the register cache.  It is assumed that the
 120      register's raw size, virtual size and type length are all the
 121      same.  */
 122
 123   {
 124     long offset = 0;
 125     descr->sizeof_register
 126       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 127     descr->register_offset
 128       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 129     for (i = 0; i < descr->nr_cooked_registers; i++)
 130       {
 131         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 132         descr->register_offset[i] = offset;
 133         offset += descr->sizeof_register[i];
 134         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 135       }
 136     /* Set the real size of the register cache buffer.  */
 137     descr->sizeof_cooked_registers = offset;
 138   }
 139
 140   /* FIXME: cagney/2002-05-22: Should only need to allocate space for
 141      the raw registers.  Unfortunately some code still accesses the
 142      register array directly using the global registers[].  Until that
 143      code has been purged, play safe and over allocating the register
 144      buffer.  Ulgh!  */
 145   descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
 146
 147   return descr;
 148 }
 149
 150 static struct regcache_descr *
 151 regcache_descr (struct gdbarch *gdbarch)
 152 {
 153   return gdbarch_data (gdbarch, regcache_descr_handle);
 154 }
 155
 156 /* Utility functions returning useful register attributes stored in
 157    the regcache descr.  */
 158
 159 struct type *
 160 register_type (struct gdbarch *gdbarch, int regnum)
 161 {
 162   struct regcache_descr *descr = regcache_descr (gdbarch);
 163   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 164   return descr->register_type[regnum];
 165 }
 166
 167 /* Utility functions returning useful register attributes stored in
 168    the regcache descr.  */
 169
 170 int
 171 register_size (struct gdbarch *gdbarch, int regnum)
 172 {
 173   struct regcache_descr *descr = regcache_descr (gdbarch);
 174   int size;
 175   gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
 176   size = descr->sizeof_register[regnum];
 177   return size;
 178 }
 179
 180 /* The register cache for storing raw register values.  */
 181
 182 struct regcache
 183 {
 184   struct regcache_descr *descr;
 185   /* The register buffers.  A read-only register cache can hold the
 186      full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
 187      register cache can only hold [0 .. NUM_REGS).  */
 188   char *registers;
 189   char *register_valid_p;
 190   /* Is this a read-only cache?  A read-only cache is used for saving
 191      the target's register state (e.g, across an inferior function
 192      call or just before forcing a function return).  A read-only
 193      cache can only be updated via the methods regcache_dup() and
 194      regcache_cpy().  The actual contents are determined by the
 195      reggroup_save and reggroup_restore methods.  */
 196   int readonly_p;
 197 };
 198
 199 struct regcache *
 200 regcache_xmalloc (struct gdbarch *gdbarch)
 201 {
 202   struct regcache_descr *descr;
 203   struct regcache *regcache;
 204   gdb_assert (gdbarch != NULL);
 205   descr = regcache_descr (gdbarch);
 206   regcache = XMALLOC (struct regcache);
 207   regcache->descr = descr;
 208   regcache->registers
 209     = XCALLOC (descr->sizeof_raw_registers, char);
 210   regcache->register_valid_p
 211     = XCALLOC (descr->sizeof_raw_register_valid_p, char);
 212   regcache->readonly_p = 1;
 213   return regcache;
 214 }
 215
 216 void
 217 regcache_xfree (struct regcache *regcache)
 218 {
 219   if (regcache == NULL)
 220     return;
 221   xfree (regcache->registers);
 222   xfree (regcache->register_valid_p);
 223   xfree (regcache);
 224 }
 225
 226 static void
 227 do_regcache_xfree (void *data)
 228 {
 229   regcache_xfree (data);
 230 }
 231
 232 struct cleanup *
 233 make_cleanup_regcache_xfree (struct regcache *regcache)
 234 {
 235   return make_cleanup (do_regcache_xfree, regcache);
 236 }
 237
 238 /* Return REGCACHE's architecture.  */
 239
 240 struct gdbarch *
 241 get_regcache_arch (const struct regcache *regcache)
 242 {
 243   return regcache->descr->gdbarch;
 244 }
 245
 246 /* Return  a pointer to register REGNUM's buffer cache.  */
 247
 248 static char *
 249 register_buffer (const struct regcache *regcache, int regnum)
 250 {
 251   return regcache->registers + regcache->descr->register_offset[regnum];
 252 }
 253
 254 void
 255 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 256                void *src)
 257 {
 258   struct gdbarch *gdbarch = dst->descr->gdbarch;
 259   char buf[MAX_REGISTER_SIZE];
 260   int regnum;
 261   /* The DST should be `read-only', if it wasn't then the save would
 262      end up trying to write the register values back out to the
 263      target.  */
 264   gdb_assert (dst->readonly_p);
 265   /* Clear the dest.  */
 266   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 267   memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
 268   /* Copy over any registers (identified by their membership in the
 269      save_reggroup) and mark them as valid.  The full [0 .. NUM_REGS +
 270      NUM_PSEUDO_REGS) range is checked since some architectures need
 271      to save/restore `cooked' registers that live in memory.  */
 272   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 273     {
 274       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 275         {
 276           int valid = cooked_read (src, regnum, buf);
 277           if (valid)
 278             {
 279               memcpy (register_buffer (dst, regnum), buf,
 280                       register_size (gdbarch, regnum));
 281               dst->register_valid_p[regnum] = 1;
 282             }
 283         }
 284     }
 285 }
 286
 287 void
 288 regcache_restore (struct regcache *dst,
 289                   regcache_cooked_read_ftype *cooked_read,
 290                   void *src)
 291 {
 292   struct gdbarch *gdbarch = dst->descr->gdbarch;
 293   char buf[MAX_REGISTER_SIZE];
 294   int regnum;
 295   /* The dst had better not be read-only.  If it is, the `restore'
 296      doesn't make much sense.  */
 297   gdb_assert (!dst->readonly_p);
 298   /* Copy over any registers, being careful to only restore those that
 299      were both saved and need to be restored.  The full [0 .. NUM_REGS
 300      + NUM_PSEUDO_REGS) range is checked since some architectures need
 301      to save/restore `cooked' registers that live in memory.  */
 302   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 303     {
 304       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 305         {
 306           int valid = cooked_read (src, regnum, buf);
 307           if (valid)
 308             regcache_cooked_write (dst, regnum, buf);
 309         }
 310     }
 311 }
 312
 313 static int
 314 do_cooked_read (void *src, int regnum, void *buf)
 315 {
 316   struct regcache *regcache = src;
 317   if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
 318     /* Don't even think about fetching a register from a read-only
 319        cache when the register isn't yet valid.  There isn't a target
 320        from which the register value can be fetched.  */
 321     return 0;
 322   regcache_cooked_read (regcache, regnum, buf);
 323   return 1;
 324 }
 325
 326
 327 void
 328 regcache_cpy (struct regcache *dst, struct regcache *src)
 329 {
 330   int i;
 331   char *buf;
 332   gdb_assert (src != NULL && dst != NULL);
 333   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 334   gdb_assert (src != dst);
 335   gdb_assert (src->readonly_p || dst->readonly_p);
 336   if (!src->readonly_p)
 337     regcache_save (dst, do_cooked_read, src);
 338   else if (!dst->readonly_p)
 339     regcache_restore (dst, do_cooked_read, src);
 340   else
 341     regcache_cpy_no_passthrough (dst, src);
 342 }
 343
 344 void
 345 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 346 {
 347   int i;
 348   gdb_assert (src != NULL && dst != NULL);
 349   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 350   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 351      move of data into the current_regcache().  Doing this would be
 352      silly - it would mean that valid_p would be completely invalid.  */
 353   gdb_assert (dst != current_regcache);
 354   memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
 355   memcpy (dst->register_valid_p, src->register_valid_p,
 356           dst->descr->sizeof_raw_register_valid_p);
 357 }
 358
 359 struct regcache *
 360 regcache_dup (struct regcache *src)
 361 {
 362   struct regcache *newbuf;
 363   gdb_assert (current_regcache != NULL);
 364   newbuf = regcache_xmalloc (src->descr->gdbarch);
 365   regcache_cpy (newbuf, src);
 366   return newbuf;
 367 }
 368
 369 struct regcache *
 370 regcache_dup_no_passthrough (struct regcache *src)
 371 {
 372   struct regcache *newbuf;
 373   gdb_assert (current_regcache != NULL);
 374   newbuf = regcache_xmalloc (src->descr->gdbarch);
 375   regcache_cpy_no_passthrough (newbuf, src);
 376   return newbuf;
 377 }
 378
 379 int
 380 regcache_valid_p (struct regcache *regcache, int regnum)
 381 {
 382   gdb_assert (regcache != NULL);
 383   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 384   return regcache->register_valid_p[regnum];
 385 }
 386
 387 char *
 388 deprecated_grub_regcache_for_registers (struct regcache *regcache)
 389 {
 390   return regcache->registers;
 391 }
 392
 393 /* Global structure containing the current regcache.  */
 394 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
 395    deprecated_register_valid[] currently point into this structure.  */
 396 struct regcache *current_regcache;
 397
 398 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 399    recording if the register values have been changed (eg. by the
 400    user).  Therefore all registers must be written back to the
 401    target when appropriate.  */
 402
 403 /* REGISTERS contains the cached register values (in target byte order). */
 404
 405 char *deprecated_registers;
 406
 407 /* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
 408                      1 if it has been fetched, and
 409                     -1 if the register value was not available.
 410
 411    "Not available" indicates that the target is not not able to supply
 412    the register at this state.  The register may become available at a
 413    later time (after the next resume).  This often occures when GDB is
 414    manipulating a target that contains only a snapshot of the entire
 415    system being debugged - some of the registers in such a system may
 416    not have been saved.  */
 417
 418 signed char *deprecated_register_valid;
 419
 420 /* The thread/process associated with the current set of registers. */
 421
 422 static ptid_t registers_ptid;
 423
 424 /*
 425  * FUNCTIONS:
 426  */
 427
 428 /* REGISTER_CACHED()
 429
 430    Returns 0 if the value is not in the cache (needs fetch).
 431           >0 if the value is in the cache.
 432           <0 if the value is permanently unavailable (don't ask again).  */
 433
 434 int
 435 register_cached (int regnum)
 436 {
 437   return deprecated_register_valid[regnum];
 438 }
 439
 440 /* Record that REGNUM's value is cached if STATE is >0, uncached but
 441    fetchable if STATE is 0, and uncached and unfetchable if STATE is <0.  */
 442
 443 void
 444 set_register_cached (int regnum, int state)
 445 {
 446   gdb_assert (regnum >= 0);
 447   gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
 448   current_regcache->register_valid_p[regnum] = state;
 449 }
 450
 451 /* Observer for the target_changed event.  */
 452
 453 void
 454 regcache_observer_target_changed (struct target_ops *target)
 455 {
 456   registers_changed ();
 457 }
 458
 459 /* Low level examining and depositing of registers.
 460
 461    The caller is responsible for making sure that the inferior is
 462    stopped before calling the fetching routines, or it will get
 463    garbage.  (a change from GDB version 3, in which the caller got the
 464    value from the last stop).  */
 465
 466 /* REGISTERS_CHANGED ()
 467
 468    Indicate that registers may have changed, so invalidate the cache.  */
 469
 470 void
 471 registers_changed (void)
 472 {
 473   int i;
 474
 475   registers_ptid = pid_to_ptid (-1);
 476
 477   /* Force cleanup of any alloca areas if using C alloca instead of
 478      a builtin alloca.  This particular call is used to clean up
 479      areas allocated by low level target code which may build up
 480      during lengthy interactions between gdb and the target before
 481      gdb gives control to the user (ie watchpoints).  */
 482   alloca (0);
 483
 484   for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
 485     set_register_cached (i, 0);
 486
 487   if (deprecated_registers_changed_hook)
 488     deprecated_registers_changed_hook ();
 489 }
 490
 491 /* DEPRECATED_REGISTERS_FETCHED ()
 492
 493    Indicate that all registers have been fetched, so mark them all valid.  */
 494
 495 /* FIXME: cagney/2001-12-04: This function is DEPRECATED.  The target
 496    code was blatting the registers[] array and then calling this.
 497    Since targets should only be using regcache_raw_supply() the need for
 498    this function/hack is eliminated.  */
 499
 500 void
 501 deprecated_registers_fetched (void)
 502 {
 503   int i;
 504
 505   for (i = 0; i < NUM_REGS; i++)
 506     set_register_cached (i, 1);
 507   /* Do not assume that the pseudo-regs have also been fetched.
 508      Fetching all real regs NEVER accounts for pseudo-regs.  */
 509 }
 510
 511 /* deprecated_read_register_bytes and deprecated_write_register_bytes
 512    are generally a *BAD* idea.  They are inefficient because they need
 513    to check for partial updates, which can only be done by scanning
 514    through all of the registers and seeing if the bytes that are being
 515    read/written fall inside of an invalid register.  [The main reason
 516    this is necessary is that register sizes can vary, so a simple
 517    index won't suffice.]  It is far better to call read_register_gen
 518    and write_register_gen if you want to get at the raw register
 519    contents, as it only takes a regnum as an argument, and therefore
 520    can't do a partial register update.
 521
 522    Prior to the recent fixes to check for partial updates, both read
 523    and deprecated_write_register_bytes always checked to see if any
 524    registers were stale, and then called target_fetch_registers (-1)
 525    to update the whole set.  This caused really slowed things down for
 526    remote targets.  */
 527
 528 /* Copy INLEN bytes of consecutive data from registers
 529    starting with the INREGBYTE'th byte of register data
 530    into memory at MYADDR.  */
 531
 532 void
 533 deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
 534 {
 535   int in_end = in_start + in_len;
 536   int regnum;
 537   char reg_buf[MAX_REGISTER_SIZE];
 538
 539   /* See if we are trying to read bytes from out-of-date registers.  If so,
 540      update just those registers.  */
 541
 542   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
 543     {
 544       int reg_start;
 545       int reg_end;
 546       int reg_len;
 547       int start;
 548       int end;
 549       int byte;
 550
 551       reg_start = DEPRECATED_REGISTER_BYTE (regnum);
 552       reg_len = register_size (current_gdbarch, regnum);
 553       reg_end = reg_start + reg_len;
 554
 555       if (reg_end <= in_start || in_end <= reg_start)
 556         /* The range the user wants to read doesn't overlap with regnum.  */
 557         continue;
 558
 559       if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
 560         /* Force the cache to fetch the entire register.  */
 561         deprecated_read_register_gen (regnum, reg_buf);
 562       else
 563         /* Legacy note: even though this register is ``invalid'' we
 564            still need to return something.  It would appear that some
 565            code relies on apparent gaps in the register array also
 566            being returned.  */
 567         /* FIXME: cagney/2001-08-18: This is just silly.  It defeats
 568            the entire register read/write flow of control.  Must
 569            resist temptation to return 0xdeadbeef.  */
 570         memcpy (reg_buf, &deprecated_registers[reg_start], reg_len);
 571
 572       /* Legacy note: This function, for some reason, allows a NULL
 573          input buffer.  If the buffer is NULL, the registers are still
 574          fetched, just the final transfer is skipped. */
 575       if (in_buf == NULL)
 576         continue;
 577
 578       /* start = max (reg_start, in_start) */
 579       if (reg_start > in_start)
 580         start = reg_start;
 581       else
 582         start = in_start;
 583
 584       /* end = min (reg_end, in_end) */
 585       if (reg_end < in_end)
 586         end = reg_end;
 587       else
 588         end = in_end;
 589
 590       /* Transfer just the bytes common to both IN_BUF and REG_BUF */
 591       for (byte = start; byte < end; byte++)
 592         {
 593           in_buf[byte - in_start] = reg_buf[byte - reg_start];
 594         }
 595     }
 596 }
 597
 598 void
 599 regcache_raw_read (struct regcache *regcache, int regnum, void *buf)
 600 {
 601   gdb_assert (regcache != NULL && buf != NULL);
 602   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 603   /* Make certain that the register cache is up-to-date with respect
 604      to the current thread.  This switching shouldn't be necessary
 605      only there is still only one target side register cache.  Sigh!
 606      On the bright side, at least there is a regcache object.  */
 607   if (!regcache->readonly_p)
 608     {
 609       gdb_assert (regcache == current_regcache);
 610       if (! ptid_equal (registers_ptid, inferior_ptid))
 611         {
 612           registers_changed ();
 613           registers_ptid = inferior_ptid;
 614         }
 615       if (!register_cached (regnum))
 616         target_fetch_registers (regnum);
 617       gdb_assert (register_cached (regnum));
 618     }
 619   /* Copy the value directly into the register cache.  */
 620   memcpy (buf, register_buffer (regcache, regnum),
 621           regcache->descr->sizeof_register[regnum]);
 622 }
 623
 624 void
 625 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 626 {
 627   char *buf;
 628   gdb_assert (regcache != NULL);
 629   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 630   buf = alloca (regcache->descr->sizeof_register[regnum]);
 631   regcache_raw_read (regcache, regnum, buf);
 632   (*val) = extract_signed_integer (buf,
 633                                    regcache->descr->sizeof_register[regnum]);
 634 }
 635
 636 void
 637 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 638                             ULONGEST *val)
 639 {
 640   char *buf;
 641   gdb_assert (regcache != NULL);
 642   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 643   buf = alloca (regcache->descr->sizeof_register[regnum]);
 644   regcache_raw_read (regcache, regnum, buf);
 645   (*val) = extract_unsigned_integer (buf,
 646                                      regcache->descr->sizeof_register[regnum]);
 647 }
 648
 649 void
 650 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 651 {
 652   void *buf;
 653   gdb_assert (regcache != NULL);
 654   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 655   buf = alloca (regcache->descr->sizeof_register[regnum]);
 656   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 657   regcache_raw_write (regcache, regnum, buf);
 658 }
 659
 660 void
 661 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 662                              ULONGEST val)
 663 {
 664   void *buf;
 665   gdb_assert (regcache != NULL);
 666   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 667   buf = alloca (regcache->descr->sizeof_register[regnum]);
 668   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 669   regcache_raw_write (regcache, regnum, buf);
 670 }
 671
 672 void
 673 deprecated_read_register_gen (int regnum, char *buf)
 674 {
 675   gdb_assert (current_regcache != NULL);
 676   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 677   regcache_cooked_read (current_regcache, regnum, buf);
 678 }
 679
 680 void
 681 regcache_cooked_read (struct regcache *regcache, int regnum, void *buf)
 682 {
 683   gdb_assert (regnum >= 0);
 684   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 685   if (regnum < regcache->descr->nr_raw_registers)
 686     regcache_raw_read (regcache, regnum, buf);
 687   else if (regcache->readonly_p
 688            && regnum < regcache->descr->nr_cooked_registers
 689            && regcache->register_valid_p[regnum])
 690     /* Read-only register cache, perhaps the cooked value was cached?  */
 691     memcpy (buf, register_buffer (regcache, regnum),
 692             regcache->descr->sizeof_register[regnum]);
 693   else
 694     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 695                                   regnum, buf);
 696 }
 697
 698 void
 699 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 700                              LONGEST *val)
 701 {
 702   char *buf;
 703   gdb_assert (regcache != NULL);
 704   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 705   buf = alloca (regcache->descr->sizeof_register[regnum]);
 706   regcache_cooked_read (regcache, regnum, buf);
 707   (*val) = extract_signed_integer (buf,
 708                                    regcache->descr->sizeof_register[regnum]);
 709 }
 710
 711 void
 712 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 713                                ULONGEST *val)
 714 {
 715   char *buf;
 716   gdb_assert (regcache != NULL);
 717   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 718   buf = alloca (regcache->descr->sizeof_register[regnum]);
 719   regcache_cooked_read (regcache, regnum, buf);
 720   (*val) = extract_unsigned_integer (buf,
 721                                      regcache->descr->sizeof_register[regnum]);
 722 }
 723
 724 void
 725 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 726                               LONGEST val)
 727 {
 728   void *buf;
 729   gdb_assert (regcache != NULL);
 730   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 731   buf = alloca (regcache->descr->sizeof_register[regnum]);
 732   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 733   regcache_cooked_write (regcache, regnum, buf);
 734 }
 735
 736 void
 737 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 738                                 ULONGEST val)
 739 {
 740   void *buf;
 741   gdb_assert (regcache != NULL);
 742   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 743   buf = alloca (regcache->descr->sizeof_register[regnum]);
 744   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 745   regcache_cooked_write (regcache, regnum, buf);
 746 }
 747
 748 void
 749 regcache_raw_write (struct regcache *regcache, int regnum, const void *buf)
 750 {
 751   gdb_assert (regcache != NULL && buf != NULL);
 752   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 753   gdb_assert (!regcache->readonly_p);
 754
 755   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 756      change the registers array if something writes to this register.  */
 757   if (CANNOT_STORE_REGISTER (regnum))
 758     return;
 759
 760   /* Make certain that the correct cache is selected.  */
 761   gdb_assert (regcache == current_regcache);
 762   if (! ptid_equal (registers_ptid, inferior_ptid))
 763     {
 764       registers_changed ();
 765       registers_ptid = inferior_ptid;
 766     }
 767
 768   /* If we have a valid copy of the register, and new value == old
 769      value, then don't bother doing the actual store. */
 770   if (regcache_valid_p (regcache, regnum)
 771       && (memcmp (register_buffer (regcache, regnum), buf,
 772                   regcache->descr->sizeof_register[regnum]) == 0))
 773     return;
 774
 775   target_prepare_to_store ();
 776   memcpy (register_buffer (regcache, regnum), buf,
 777           regcache->descr->sizeof_register[regnum]);
 778   regcache->register_valid_p[regnum] = 1;
 779   target_store_registers (regnum);
 780 }
 781
 782 void
 783 deprecated_write_register_gen (int regnum, char *buf)
 784 {
 785   gdb_assert (current_regcache != NULL);
 786   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 787   regcache_cooked_write (current_regcache, regnum, buf);
 788 }
 789
 790 void
 791 regcache_cooked_write (struct regcache *regcache, int regnum, const void *buf)
 792 {
 793   gdb_assert (regnum >= 0);
 794   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 795   if (regnum < regcache->descr->nr_raw_registers)
 796     regcache_raw_write (regcache, regnum, buf);
 797   else
 798     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 799                                    regnum, buf);
 800 }
 801
 802 /* Copy INLEN bytes of consecutive data from memory at MYADDR
 803    into registers starting with the MYREGSTART'th byte of register data.  */
 804
 805 void
 806 deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
 807 {
 808   int myregend = myregstart + inlen;
 809   int regnum;
 810
 811   target_prepare_to_store ();
 812
 813   /* Scan through the registers updating any that are covered by the
 814      range myregstart<=>myregend using write_register_gen, which does
 815      nice things like handling threads, and avoiding updates when the
 816      new and old contents are the same.  */
 817
 818   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
 819     {
 820       int regstart, regend;
 821
 822       regstart = DEPRECATED_REGISTER_BYTE (regnum);
 823       regend = regstart + register_size (current_gdbarch, regnum);
 824
 825       /* Is this register completely outside the range the user is writing?  */
 826       if (myregend <= regstart || regend <= myregstart)
 827         /* do nothing */ ;
 828
 829       /* Is this register completely within the range the user is writing?  */
 830       else if (myregstart <= regstart && regend <= myregend)
 831         deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart));
 832
 833       /* The register partially overlaps the range being written.  */
 834       else
 835         {
 836           char regbuf[MAX_REGISTER_SIZE];
 837           /* What's the overlap between this register's bytes and
 838              those the caller wants to write?  */
 839           int overlapstart = max (regstart, myregstart);
 840           int overlapend   = min (regend,   myregend);
 841
 842           /* We may be doing a partial update of an invalid register.
 843              Update it from the target before scribbling on it.  */
 844           deprecated_read_register_gen (regnum, regbuf);
 845
 846           memcpy (&deprecated_registers[overlapstart],
 847                   myaddr + (overlapstart - myregstart),
 848                   overlapend - overlapstart);
 849
 850           target_store_registers (regnum);
 851         }
 852     }
 853 }
 854
 855 /* Perform a partial register transfer using a read, modify, write
 856    operation.  */
 857
 858 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 859                                     void *buf);
 860 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 861                                      const void *buf);
 862
 863 static void
 864 regcache_xfer_part (struct regcache *regcache, int regnum,
 865                     int offset, int len, void *in, const void *out,
 866                     regcache_read_ftype *read, regcache_write_ftype *write)
 867 {
 868   struct regcache_descr *descr = regcache->descr;
 869   bfd_byte reg[MAX_REGISTER_SIZE];
 870   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 871   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 872   /* Something to do?  */
 873   if (offset + len == 0)
 874     return;
 875   /* Read (when needed) ... */
 876   if (in != NULL
 877       || offset > 0
 878       || offset + len < descr->sizeof_register[regnum])
 879     {
 880       gdb_assert (read != NULL);
 881       read (regcache, regnum, reg);
 882     }
 883   /* ... modify ... */
 884   if (in != NULL)
 885     memcpy (in, reg + offset, len);
 886   if (out != NULL)
 887     memcpy (reg + offset, out, len);
 888   /* ... write (when needed).  */
 889   if (out != NULL)
 890     {
 891       gdb_assert (write != NULL);
 892       write (regcache, regnum, reg);
 893     }
 894 }
 895
 896 void
 897 regcache_raw_read_part (struct regcache *regcache, int regnum,
 898                         int offset, int len, void *buf)
 899 {
 900   struct regcache_descr *descr = regcache->descr;
 901   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 902   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 903                       regcache_raw_read, regcache_raw_write);
 904 }
 905
 906 void
 907 regcache_raw_write_part (struct regcache *regcache, int regnum,
 908                          int offset, int len, const void *buf)
 909 {
 910   struct regcache_descr *descr = regcache->descr;
 911   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 912   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 913                       regcache_raw_read, regcache_raw_write);
 914 }
 915
 916 void
 917 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 918                            int offset, int len, void *buf)
 919 {
 920   struct regcache_descr *descr = regcache->descr;
 921   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 922   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 923                       regcache_cooked_read, regcache_cooked_write);
 924 }
 925
 926 void
 927 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 928                             int offset, int len, const void *buf)
 929 {
 930   struct regcache_descr *descr = regcache->descr;
 931   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 932   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 933                       regcache_cooked_read, regcache_cooked_write);
 934 }
 935
 936 /* Hack to keep code that view the register buffer as raw bytes
 937    working.  */
 938
 939 int
 940 register_offset_hack (struct gdbarch *gdbarch, int regnum)
 941 {
 942   struct regcache_descr *descr = regcache_descr (gdbarch);
 943   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 944   return descr->register_offset[regnum];
 945 }
 946
 947 /* Hack to keep code using register_bytes working.  */
 948
 949 int
 950 deprecated_register_bytes (void)
 951 {
 952   return current_regcache->descr->sizeof_raw_registers;
 953 }
 954
 955 /* Return the contents of register REGNUM as an unsigned integer.  */
 956
 957 ULONGEST
 958 read_register (int regnum)
 959 {
 960   char *buf = alloca (register_size (current_gdbarch, regnum));
 961   deprecated_read_register_gen (regnum, buf);
 962   return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
 963 }
 964
 965 ULONGEST
 966 read_register_pid (int regnum, ptid_t ptid)
 967 {
 968   ptid_t save_ptid;
 969   int save_pid;
 970   CORE_ADDR retval;
 971
 972   if (ptid_equal (ptid, inferior_ptid))
 973     return read_register (regnum);
 974
 975   save_ptid = inferior_ptid;
 976
 977   inferior_ptid = ptid;
 978
 979   retval = read_register (regnum);
 980
 981   inferior_ptid = save_ptid;
 982
 983   return retval;
 984 }
 985
 986 /* Store VALUE into the raw contents of register number REGNUM.  */
 987
 988 void
 989 write_register (int regnum, LONGEST val)
 990 {
 991   void *buf;
 992   int size;
 993   size = register_size (current_gdbarch, regnum);
 994   buf = alloca (size);
 995   store_signed_integer (buf, size, (LONGEST) val);
 996   deprecated_write_register_gen (regnum, buf);
 997 }
 998
 999 void
1000 write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
1001 {
1002   ptid_t save_ptid;
1003
1004   if (ptid_equal (ptid, inferior_ptid))
1005     {
1006       write_register (regnum, val);
1007       return;
1008     }
1009
1010   save_ptid = inferior_ptid;
1011
1012   inferior_ptid = ptid;
1013
1014   write_register (regnum, val);
1015
1016   inferior_ptid = save_ptid;
1017 }
1018
1019 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
1020
1021 void
1022 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1023 {
1024   void *regbuf;
1025   size_t size;
1026
1027   gdb_assert (regcache != NULL);
1028   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1029   gdb_assert (!regcache->readonly_p);
1030
1031   /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
1032      CURRENT_REGCACHE specially here.  */
1033   if (regcache == current_regcache
1034       && !ptid_equal (registers_ptid, inferior_ptid))
1035     {
1036       registers_changed ();
1037       registers_ptid = inferior_ptid;
1038     }
1039
1040   regbuf = register_buffer (regcache, regnum);
1041   size = regcache->descr->sizeof_register[regnum];
1042
1043   if (buf)
1044     memcpy (regbuf, buf, size);
1045   else
1046     memset (regbuf, 0, size);
1047
1048   /* Mark the register as cached.  */
1049   regcache->register_valid_p[regnum] = 1;
1050 }
1051
1052 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
1053
1054 void
1055 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1056 {
1057   const void *regbuf;
1058   size_t size;
1059
1060   gdb_assert (regcache != NULL && buf != NULL);
1061   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1062
1063   regbuf = register_buffer (regcache, regnum);
1064   size = regcache->descr->sizeof_register[regnum];
1065   memcpy (buf, regbuf, size);
1066 }
1067
1068
1069 /* read_pc, write_pc, read_sp, deprecated_read_fp, etc.  Special
1070    handling for registers PC, SP, and FP.  */
1071
1072 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
1073    read_sp(), and deprecated_read_fp(), will eventually be replaced by
1074    per-frame methods.  Instead of relying on the global INFERIOR_PTID,
1075    they will use the contextual information provided by the FRAME.
1076    These functions do not belong in the register cache.  */
1077
1078 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
1079    write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
1080    be replaced by something that does not rely on global state.  But
1081    what?  */
1082
1083 CORE_ADDR
1084 read_pc_pid (ptid_t ptid)
1085 {
1086   ptid_t saved_inferior_ptid;
1087   CORE_ADDR pc_val;
1088
1089   /* In case ptid != inferior_ptid. */
1090   saved_inferior_ptid = inferior_ptid;
1091   inferior_ptid = ptid;
1092
1093   if (TARGET_READ_PC_P ())
1094     pc_val = TARGET_READ_PC (ptid);
1095   /* Else use per-frame method on get_current_frame.  */
1096   else if (PC_REGNUM >= 0)
1097     {
1098       CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
1099       pc_val = ADDR_BITS_REMOVE (raw_val);
1100     }
1101   else
1102     internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
1103
1104   inferior_ptid = saved_inferior_ptid;
1105   return pc_val;
1106 }
1107
1108 CORE_ADDR
1109 read_pc (void)
1110 {
1111   return read_pc_pid (inferior_ptid);
1112 }
1113
1114 void
1115 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
1116 {
1117   if (PC_REGNUM >= 0)
1118     write_register_pid (PC_REGNUM, pc, ptid);
1119   else
1120     internal_error (__FILE__, __LINE__,
1121                     "generic_target_write_pc");
1122 }
1123
1124 void
1125 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1126 {
1127   ptid_t saved_inferior_ptid;
1128
1129   /* In case ptid != inferior_ptid. */
1130   saved_inferior_ptid = inferior_ptid;
1131   inferior_ptid = ptid;
1132
1133   TARGET_WRITE_PC (pc, ptid);
1134
1135   inferior_ptid = saved_inferior_ptid;
1136 }
1137
1138 void
1139 write_pc (CORE_ADDR pc)
1140 {
1141   write_pc_pid (pc, inferior_ptid);
1142 }
1143
1144 /* Cope with strage ways of getting to the stack and frame pointers */
1145
1146 CORE_ADDR
1147 read_sp (void)
1148 {
1149   if (TARGET_READ_SP_P ())
1150     return TARGET_READ_SP ();
1151   else if (gdbarch_unwind_sp_p (current_gdbarch))
1152     return get_frame_sp (get_current_frame ());
1153   else if (SP_REGNUM >= 0)
1154     /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1155        about the architecture so put it at the end.  */
1156     return read_register (SP_REGNUM);
1157   internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
1158 }
1159
1160 void
1161 deprecated_write_sp (CORE_ADDR val)
1162 {
1163   gdb_assert (SP_REGNUM >= 0);
1164   write_register (SP_REGNUM, val);
1165 }
1166
1167 CORE_ADDR
1168 deprecated_read_fp (void)
1169 {
1170   if (DEPRECATED_FP_REGNUM >= 0)
1171     return read_register (DEPRECATED_FP_REGNUM);
1172   else
1173     internal_error (__FILE__, __LINE__, "deprecated_read_fp");
1174 }
1175
1176 static void
1177 reg_flush_command (char *command, int from_tty)
1178 {
1179   /* Force-flush the register cache.  */
1180   registers_changed ();
1181   if (from_tty)
1182     printf_filtered ("Register cache flushed.\n");
1183 }
1184
1185 static void
1186 build_regcache (void)
1187 {
1188   current_regcache = regcache_xmalloc (current_gdbarch);
1189   current_regcache->readonly_p = 0;
1190   deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
1191   deprecated_register_valid = current_regcache->register_valid_p;
1192 }
1193
1194 static void
1195 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1196                    const unsigned char *buf, long len)
1197 {
1198   int i;
1199   switch (endian)
1200     {
1201     case BFD_ENDIAN_BIG:
1202       for (i = 0; i < len; i++)
1203         fprintf_unfiltered (file, "%02x", buf[i]);
1204       break;
1205     case BFD_ENDIAN_LITTLE:
1206       for (i = len - 1; i >= 0; i--)
1207         fprintf_unfiltered (file, "%02x", buf[i]);
1208       break;
1209     default:
1210       internal_error (__FILE__, __LINE__, "Bad switch");
1211     }
1212 }
1213
1214 enum regcache_dump_what
1215 {
1216   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1217 };
1218
1219 static void
1220 regcache_dump (struct regcache *regcache, struct ui_file *file,
1221                enum regcache_dump_what what_to_dump)
1222 {
1223   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1224   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1225   int regnum;
1226   int footnote_nr = 0;
1227   int footnote_register_size = 0;
1228   int footnote_register_offset = 0;
1229   int footnote_register_type_name_null = 0;
1230   long register_offset = 0;
1231   unsigned char buf[MAX_REGISTER_SIZE];
1232
1233 #if 0
1234   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1235                       regcache->descr->nr_raw_registers);
1236   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1237                       regcache->descr->nr_cooked_registers);
1238   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1239                       regcache->descr->sizeof_raw_registers);
1240   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1241                       regcache->descr->sizeof_raw_register_valid_p);
1242   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1243   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1244 #endif
1245
1246   gdb_assert (regcache->descr->nr_cooked_registers
1247               == (NUM_REGS + NUM_PSEUDO_REGS));
1248
1249   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1250     {
1251       /* Name.  */
1252       if (regnum < 0)
1253         fprintf_unfiltered (file, " %-10s", "Name");
1254       else
1255         {
1256           const char *p = REGISTER_NAME (regnum);
1257           if (p == NULL)
1258             p = "";
1259           else if (p[0] == '\0')
1260             p = "''";
1261           fprintf_unfiltered (file, " %-10s", p);
1262         }
1263
1264       /* Number.  */
1265       if (regnum < 0)
1266         fprintf_unfiltered (file, " %4s", "Nr");
1267       else
1268         fprintf_unfiltered (file, " %4d", regnum);
1269
1270       /* Relative number.  */
1271       if (regnum < 0)
1272         fprintf_unfiltered (file, " %4s", "Rel");
1273       else if (regnum < NUM_REGS)
1274         fprintf_unfiltered (file, " %4d", regnum);
1275       else
1276         fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1277
1278       /* Offset.  */
1279       if (regnum < 0)
1280         fprintf_unfiltered (file, " %6s  ", "Offset");
1281       else
1282         {
1283           fprintf_unfiltered (file, " %6ld",
1284                               regcache->descr->register_offset[regnum]);
1285           if (register_offset != regcache->descr->register_offset[regnum]
1286               || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
1287               || (regnum > 0
1288                   && (regcache->descr->register_offset[regnum]
1289                       != (regcache->descr->register_offset[regnum - 1]
1290                           + regcache->descr->sizeof_register[regnum - 1])))
1291               )
1292             {
1293               if (!footnote_register_offset)
1294                 footnote_register_offset = ++footnote_nr;
1295               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1296             }
1297           else
1298             fprintf_unfiltered (file, "  ");
1299           register_offset = (regcache->descr->register_offset[regnum]
1300                              + regcache->descr->sizeof_register[regnum]);
1301         }
1302
1303       /* Size.  */
1304       if (regnum < 0)
1305         fprintf_unfiltered (file, " %5s ", "Size");
1306       else
1307         fprintf_unfiltered (file, " %5ld",
1308                             regcache->descr->sizeof_register[regnum]);
1309
1310       /* Type.  */
1311       {
1312         const char *t;
1313         if (regnum < 0)
1314           t = "Type";
1315         else
1316           {
1317             static const char blt[] = "builtin_type";
1318             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1319             if (t == NULL)
1320               {
1321                 char *n;
1322                 if (!footnote_register_type_name_null)
1323                   footnote_register_type_name_null = ++footnote_nr;
1324                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1325                 make_cleanup (xfree, n);
1326                 t = n;
1327               }
1328             /* Chop a leading builtin_type.  */
1329             if (strncmp (t, blt, strlen (blt)) == 0)
1330               t += strlen (blt);
1331           }
1332         fprintf_unfiltered (file, " %-15s", t);
1333       }
1334
1335       /* Leading space always present.  */
1336       fprintf_unfiltered (file, " ");
1337
1338       /* Value, raw.  */
1339       if (what_to_dump == regcache_dump_raw)
1340         {
1341           if (regnum < 0)
1342             fprintf_unfiltered (file, "Raw value");
1343           else if (regnum >= regcache->descr->nr_raw_registers)
1344             fprintf_unfiltered (file, "<cooked>");
1345           else if (!regcache_valid_p (regcache, regnum))
1346             fprintf_unfiltered (file, "<invalid>");
1347           else
1348             {
1349               regcache_raw_read (regcache, regnum, buf);
1350               fprintf_unfiltered (file, "0x");
1351               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1352                                  regcache->descr->sizeof_register[regnum]);
1353             }
1354         }
1355
1356       /* Value, cooked.  */
1357       if (what_to_dump == regcache_dump_cooked)
1358         {
1359           if (regnum < 0)
1360             fprintf_unfiltered (file, "Cooked value");
1361           else
1362             {
1363               regcache_cooked_read (regcache, regnum, buf);
1364               fprintf_unfiltered (file, "0x");
1365               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1366                                  regcache->descr->sizeof_register[regnum]);
1367             }
1368         }
1369
1370       /* Group members.  */
1371       if (what_to_dump == regcache_dump_groups)
1372         {
1373           if (regnum < 0)
1374             fprintf_unfiltered (file, "Groups");
1375           else
1376             {
1377               const char *sep = "";
1378               struct reggroup *group;
1379               for (group = reggroup_next (gdbarch, NULL);
1380                    group != NULL;
1381                    group = reggroup_next (gdbarch, group))
1382                 {
1383                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1384                     {
1385                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1386                       sep = ",";
1387                     }
1388                 }
1389             }
1390         }
1391
1392       fprintf_unfiltered (file, "\n");
1393     }
1394
1395   if (footnote_register_size)
1396     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1397                         footnote_register_size);
1398   if (footnote_register_offset)
1399     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1400                         footnote_register_offset);
1401   if (footnote_register_type_name_null)
1402     fprintf_unfiltered (file,
1403                         "*%d: Register type's name NULL.\n",
1404                         footnote_register_type_name_null);
1405   do_cleanups (cleanups);
1406 }
1407
1408 static void
1409 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1410 {
1411   if (args == NULL)
1412     regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1413   else
1414     {
1415       struct ui_file *file = gdb_fopen (args, "w");
1416       if (file == NULL)
1417         perror_with_name ("maintenance print architecture");
1418       regcache_dump (current_regcache, file, what_to_dump);
1419       ui_file_delete (file);
1420     }
1421 }
1422
1423 static void
1424 maintenance_print_registers (char *args, int from_tty)
1425 {
1426   regcache_print (args, regcache_dump_none);
1427 }
1428
1429 static void
1430 maintenance_print_raw_registers (char *args, int from_tty)
1431 {
1432   regcache_print (args, regcache_dump_raw);
1433 }
1434
1435 static void
1436 maintenance_print_cooked_registers (char *args, int from_tty)
1437 {
1438   regcache_print (args, regcache_dump_cooked);
1439 }
1440
1441 static void
1442 maintenance_print_register_groups (char *args, int from_tty)
1443 {
1444   regcache_print (args, regcache_dump_groups);
1445 }
1446
1447 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1448
1449 void
1450 _initialize_regcache (void)
1451 {
1452   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1453   DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1454   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers);
1455   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid);
1456   deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1457
1458   observer_attach_target_changed (regcache_observer_target_changed);
1459
1460   add_com ("flushregs", class_maintenance, reg_flush_command,
1461            "Force gdb to flush its register cache (maintainer command)");
1462
1463    /* Initialize the thread/process associated with the current set of
1464       registers.  For now, -1 is special, and means `no current process'.  */
1465   registers_ptid = pid_to_ptid (-1);
1466
1467   add_cmd ("registers", class_maintenance,
1468            maintenance_print_registers,
1469            "Print the internal register configuration.\
1470 Takes an optional file parameter.",
1471            &maintenanceprintlist);
1472   add_cmd ("raw-registers", class_maintenance,
1473            maintenance_print_raw_registers,
1474            "Print the internal register configuration including raw values.\
1475 Takes an optional file parameter.",
1476            &maintenanceprintlist);
1477   add_cmd ("cooked-registers", class_maintenance,
1478            maintenance_print_cooked_registers,
1479            "Print the internal register configuration including cooked values.\
1480 Takes an optional file parameter.",
1481            &maintenanceprintlist);
1482   add_cmd ("register-groups", class_maintenance,
1483            maintenance_print_register_groups,
1484            "Print the internal register configuration including each register's group.\
1485 Takes an optional file parameter.",
1486            &maintenanceprintlist);
1487
1488 }