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, etc.  Special handling for registers
1070    PC, SP, and FP.  */
1071
1072 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
1073    read_sp(), will eventually be replaced by per-frame methods.
1074    Instead of relying on the global INFERIOR_PTID, they will use the
1075    contextual information provided by the FRAME.  These functions do
1076    not belong in the register cache.  */
1077
1078 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
1079    write_pc_pid() and write_pc(), all need to be replaced by something
1080    that does not rely on global state.  But what?  */
1081
1082 CORE_ADDR
1083 read_pc_pid (ptid_t ptid)
1084 {
1085   ptid_t saved_inferior_ptid;
1086   CORE_ADDR pc_val;
1087
1088   /* In case ptid != inferior_ptid. */
1089   saved_inferior_ptid = inferior_ptid;
1090   inferior_ptid = ptid;
1091
1092   if (TARGET_READ_PC_P ())
1093     pc_val = TARGET_READ_PC (ptid);
1094   /* Else use per-frame method on get_current_frame.  */
1095   else if (PC_REGNUM >= 0)
1096     {
1097       CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
1098       pc_val = ADDR_BITS_REMOVE (raw_val);
1099     }
1100   else
1101     internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
1102
1103   inferior_ptid = saved_inferior_ptid;
1104   return pc_val;
1105 }
1106
1107 CORE_ADDR
1108 read_pc (void)
1109 {
1110   return read_pc_pid (inferior_ptid);
1111 }
1112
1113 void
1114 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
1115 {
1116   if (PC_REGNUM >= 0)
1117     write_register_pid (PC_REGNUM, pc, ptid);
1118   else
1119     internal_error (__FILE__, __LINE__,
1120                     "generic_target_write_pc");
1121 }
1122
1123 void
1124 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1125 {
1126   ptid_t saved_inferior_ptid;
1127
1128   /* In case ptid != inferior_ptid. */
1129   saved_inferior_ptid = inferior_ptid;
1130   inferior_ptid = ptid;
1131
1132   TARGET_WRITE_PC (pc, ptid);
1133
1134   inferior_ptid = saved_inferior_ptid;
1135 }
1136
1137 void
1138 write_pc (CORE_ADDR pc)
1139 {
1140   write_pc_pid (pc, inferior_ptid);
1141 }
1142
1143 /* Cope with strage ways of getting to the stack and frame pointers */
1144
1145 CORE_ADDR
1146 read_sp (void)
1147 {
1148   if (TARGET_READ_SP_P ())
1149     return TARGET_READ_SP ();
1150   else if (gdbarch_unwind_sp_p (current_gdbarch))
1151     return get_frame_sp (get_current_frame ());
1152   else if (SP_REGNUM >= 0)
1153     /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1154        about the architecture so put it at the end.  */
1155     return read_register (SP_REGNUM);
1156   internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
1157 }
1158
1159 static void
1160 reg_flush_command (char *command, int from_tty)
1161 {
1162   /* Force-flush the register cache.  */
1163   registers_changed ();
1164   if (from_tty)
1165     printf_filtered ("Register cache flushed.\n");
1166 }
1167
1168 static void
1169 build_regcache (void)
1170 {
1171   current_regcache = regcache_xmalloc (current_gdbarch);
1172   current_regcache->readonly_p = 0;
1173   deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
1174   deprecated_register_valid = current_regcache->register_valid_p;
1175 }
1176
1177 static void
1178 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1179                    const unsigned char *buf, long len)
1180 {
1181   int i;
1182   switch (endian)
1183     {
1184     case BFD_ENDIAN_BIG:
1185       for (i = 0; i < len; i++)
1186         fprintf_unfiltered (file, "%02x", buf[i]);
1187       break;
1188     case BFD_ENDIAN_LITTLE:
1189       for (i = len - 1; i >= 0; i--)
1190         fprintf_unfiltered (file, "%02x", buf[i]);
1191       break;
1192     default:
1193       internal_error (__FILE__, __LINE__, "Bad switch");
1194     }
1195 }
1196
1197 enum regcache_dump_what
1198 {
1199   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1200 };
1201
1202 static void
1203 regcache_dump (struct regcache *regcache, struct ui_file *file,
1204                enum regcache_dump_what what_to_dump)
1205 {
1206   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1207   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1208   int regnum;
1209   int footnote_nr = 0;
1210   int footnote_register_size = 0;
1211   int footnote_register_offset = 0;
1212   int footnote_register_type_name_null = 0;
1213   long register_offset = 0;
1214   unsigned char buf[MAX_REGISTER_SIZE];
1215
1216 #if 0
1217   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1218                       regcache->descr->nr_raw_registers);
1219   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1220                       regcache->descr->nr_cooked_registers);
1221   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1222                       regcache->descr->sizeof_raw_registers);
1223   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1224                       regcache->descr->sizeof_raw_register_valid_p);
1225   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1226   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1227 #endif
1228
1229   gdb_assert (regcache->descr->nr_cooked_registers
1230               == (NUM_REGS + NUM_PSEUDO_REGS));
1231
1232   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1233     {
1234       /* Name.  */
1235       if (regnum < 0)
1236         fprintf_unfiltered (file, " %-10s", "Name");
1237       else
1238         {
1239           const char *p = REGISTER_NAME (regnum);
1240           if (p == NULL)
1241             p = "";
1242           else if (p[0] == '\0')
1243             p = "''";
1244           fprintf_unfiltered (file, " %-10s", p);
1245         }
1246
1247       /* Number.  */
1248       if (regnum < 0)
1249         fprintf_unfiltered (file, " %4s", "Nr");
1250       else
1251         fprintf_unfiltered (file, " %4d", regnum);
1252
1253       /* Relative number.  */
1254       if (regnum < 0)
1255         fprintf_unfiltered (file, " %4s", "Rel");
1256       else if (regnum < NUM_REGS)
1257         fprintf_unfiltered (file, " %4d", regnum);
1258       else
1259         fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1260
1261       /* Offset.  */
1262       if (regnum < 0)
1263         fprintf_unfiltered (file, " %6s  ", "Offset");
1264       else
1265         {
1266           fprintf_unfiltered (file, " %6ld",
1267                               regcache->descr->register_offset[regnum]);
1268           if (register_offset != regcache->descr->register_offset[regnum]
1269               || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
1270               || (regnum > 0
1271                   && (regcache->descr->register_offset[regnum]
1272                       != (regcache->descr->register_offset[regnum - 1]
1273                           + regcache->descr->sizeof_register[regnum - 1])))
1274               )
1275             {
1276               if (!footnote_register_offset)
1277                 footnote_register_offset = ++footnote_nr;
1278               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1279             }
1280           else
1281             fprintf_unfiltered (file, "  ");
1282           register_offset = (regcache->descr->register_offset[regnum]
1283                              + regcache->descr->sizeof_register[regnum]);
1284         }
1285
1286       /* Size.  */
1287       if (regnum < 0)
1288         fprintf_unfiltered (file, " %5s ", "Size");
1289       else
1290         fprintf_unfiltered (file, " %5ld",
1291                             regcache->descr->sizeof_register[regnum]);
1292
1293       /* Type.  */
1294       {
1295         const char *t;
1296         if (regnum < 0)
1297           t = "Type";
1298         else
1299           {
1300             static const char blt[] = "builtin_type";
1301             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1302             if (t == NULL)
1303               {
1304                 char *n;
1305                 if (!footnote_register_type_name_null)
1306                   footnote_register_type_name_null = ++footnote_nr;
1307                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1308                 make_cleanup (xfree, n);
1309                 t = n;
1310               }
1311             /* Chop a leading builtin_type.  */
1312             if (strncmp (t, blt, strlen (blt)) == 0)
1313               t += strlen (blt);
1314           }
1315         fprintf_unfiltered (file, " %-15s", t);
1316       }
1317
1318       /* Leading space always present.  */
1319       fprintf_unfiltered (file, " ");
1320
1321       /* Value, raw.  */
1322       if (what_to_dump == regcache_dump_raw)
1323         {
1324           if (regnum < 0)
1325             fprintf_unfiltered (file, "Raw value");
1326           else if (regnum >= regcache->descr->nr_raw_registers)
1327             fprintf_unfiltered (file, "<cooked>");
1328           else if (!regcache_valid_p (regcache, regnum))
1329             fprintf_unfiltered (file, "<invalid>");
1330           else
1331             {
1332               regcache_raw_read (regcache, regnum, buf);
1333               fprintf_unfiltered (file, "0x");
1334               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1335                                  regcache->descr->sizeof_register[regnum]);
1336             }
1337         }
1338
1339       /* Value, cooked.  */
1340       if (what_to_dump == regcache_dump_cooked)
1341         {
1342           if (regnum < 0)
1343             fprintf_unfiltered (file, "Cooked value");
1344           else
1345             {
1346               regcache_cooked_read (regcache, regnum, buf);
1347               fprintf_unfiltered (file, "0x");
1348               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1349                                  regcache->descr->sizeof_register[regnum]);
1350             }
1351         }
1352
1353       /* Group members.  */
1354       if (what_to_dump == regcache_dump_groups)
1355         {
1356           if (regnum < 0)
1357             fprintf_unfiltered (file, "Groups");
1358           else
1359             {
1360               const char *sep = "";
1361               struct reggroup *group;
1362               for (group = reggroup_next (gdbarch, NULL);
1363                    group != NULL;
1364                    group = reggroup_next (gdbarch, group))
1365                 {
1366                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1367                     {
1368                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1369                       sep = ",";
1370                     }
1371                 }
1372             }
1373         }
1374
1375       fprintf_unfiltered (file, "\n");
1376     }
1377
1378   if (footnote_register_size)
1379     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1380                         footnote_register_size);
1381   if (footnote_register_offset)
1382     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1383                         footnote_register_offset);
1384   if (footnote_register_type_name_null)
1385     fprintf_unfiltered (file,
1386                         "*%d: Register type's name NULL.\n",
1387                         footnote_register_type_name_null);
1388   do_cleanups (cleanups);
1389 }
1390
1391 static void
1392 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1393 {
1394   if (args == NULL)
1395     regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1396   else
1397     {
1398       struct ui_file *file = gdb_fopen (args, "w");
1399       if (file == NULL)
1400         perror_with_name ("maintenance print architecture");
1401       regcache_dump (current_regcache, file, what_to_dump);
1402       ui_file_delete (file);
1403     }
1404 }
1405
1406 static void
1407 maintenance_print_registers (char *args, int from_tty)
1408 {
1409   regcache_print (args, regcache_dump_none);
1410 }
1411
1412 static void
1413 maintenance_print_raw_registers (char *args, int from_tty)
1414 {
1415   regcache_print (args, regcache_dump_raw);
1416 }
1417
1418 static void
1419 maintenance_print_cooked_registers (char *args, int from_tty)
1420 {
1421   regcache_print (args, regcache_dump_cooked);
1422 }
1423
1424 static void
1425 maintenance_print_register_groups (char *args, int from_tty)
1426 {
1427   regcache_print (args, regcache_dump_groups);
1428 }
1429
1430 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1431
1432 void
1433 _initialize_regcache (void)
1434 {
1435   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1436   DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1437   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers);
1438   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid);
1439   deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1440
1441   observer_attach_target_changed (regcache_observer_target_changed);
1442
1443   add_com ("flushregs", class_maintenance, reg_flush_command,
1444            "Force gdb to flush its register cache (maintainer command)");
1445
1446    /* Initialize the thread/process associated with the current set of
1447       registers.  For now, -1 is special, and means `no current process'.  */
1448   registers_ptid = pid_to_ptid (-1);
1449
1450   add_cmd ("registers", class_maintenance,
1451            maintenance_print_registers,
1452            "Print the internal register configuration.\
1453 Takes an optional file parameter.",
1454            &maintenanceprintlist);
1455   add_cmd ("raw-registers", class_maintenance,
1456            maintenance_print_raw_registers,
1457            "Print the internal register configuration including raw values.\
1458 Takes an optional file parameter.",
1459            &maintenanceprintlist);
1460   add_cmd ("cooked-registers", class_maintenance,
1461            maintenance_print_cooked_registers,
1462            "Print the internal register configuration including cooked values.\
1463 Takes an optional file parameter.",
1464            &maintenanceprintlist);
1465   add_cmd ("register-groups", class_maintenance,
1466            maintenance_print_register_groups,
1467            "Print the internal register configuration including each register's group.\
1468 Takes an optional file parameter.",
1469            &maintenanceprintlist);
1470
1471 }