gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
   4    2002, 2004, 2007 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., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, 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 registers 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   gdb_byte *registers;
 189   /* Register cache status:
 190      register_valid_p[REG] == 0 if REG value is not in the cache
 191                             > 0 if REG value is in the cache
 192                             < 0 if REG value is permanently unavailable */
 193   signed char *register_valid_p;
 194   /* Is this a read-only cache?  A read-only cache is used for saving
 195      the target's register state (e.g, across an inferior function
 196      call or just before forcing a function return).  A read-only
 197      cache can only be updated via the methods regcache_dup() and
 198      regcache_cpy().  The actual contents are determined by the
 199      reggroup_save and reggroup_restore methods.  */
 200   int readonly_p;
 201 };
 202
 203 struct regcache *
 204 regcache_xmalloc (struct gdbarch *gdbarch)
 205 {
 206   struct regcache_descr *descr;
 207   struct regcache *regcache;
 208   gdb_assert (gdbarch != NULL);
 209   descr = regcache_descr (gdbarch);
 210   regcache = XMALLOC (struct regcache);
 211   regcache->descr = descr;
 212   regcache->registers
 213     = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
 214   regcache->register_valid_p
 215     = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
 216   regcache->readonly_p = 1;
 217   return regcache;
 218 }
 219
 220 void
 221 regcache_xfree (struct regcache *regcache)
 222 {
 223   if (regcache == NULL)
 224     return;
 225   xfree (regcache->registers);
 226   xfree (regcache->register_valid_p);
 227   xfree (regcache);
 228 }
 229
 230 static void
 231 do_regcache_xfree (void *data)
 232 {
 233   regcache_xfree (data);
 234 }
 235
 236 struct cleanup *
 237 make_cleanup_regcache_xfree (struct regcache *regcache)
 238 {
 239   return make_cleanup (do_regcache_xfree, regcache);
 240 }
 241
 242 /* Return REGCACHE's architecture.  */
 243
 244 struct gdbarch *
 245 get_regcache_arch (const struct regcache *regcache)
 246 {
 247   return regcache->descr->gdbarch;
 248 }
 249
 250 /* Return  a pointer to register REGNUM's buffer cache.  */
 251
 252 static gdb_byte *
 253 register_buffer (const struct regcache *regcache, int regnum)
 254 {
 255   return regcache->registers + regcache->descr->register_offset[regnum];
 256 }
 257
 258 void
 259 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 260                void *src)
 261 {
 262   struct gdbarch *gdbarch = dst->descr->gdbarch;
 263   gdb_byte buf[MAX_REGISTER_SIZE];
 264   int regnum;
 265   /* The DST should be `read-only', if it wasn't then the save would
 266      end up trying to write the register values back out to the
 267      target.  */
 268   gdb_assert (dst->readonly_p);
 269   /* Clear the dest.  */
 270   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 271   memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
 272   /* Copy over any registers (identified by their membership in the
 273      save_reggroup) and mark them as valid.  The full [0 .. NUM_REGS +
 274      NUM_PSEUDO_REGS) range is checked since some architectures need
 275      to save/restore `cooked' registers that live in memory.  */
 276   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 277     {
 278       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 279         {
 280           int valid = cooked_read (src, regnum, buf);
 281           if (valid)
 282             {
 283               memcpy (register_buffer (dst, regnum), buf,
 284                       register_size (gdbarch, regnum));
 285               dst->register_valid_p[regnum] = 1;
 286             }
 287         }
 288     }
 289 }
 290
 291 void
 292 regcache_restore (struct regcache *dst,
 293                   regcache_cooked_read_ftype *cooked_read,
 294                   void *cooked_read_context)
 295 {
 296   struct gdbarch *gdbarch = dst->descr->gdbarch;
 297   gdb_byte buf[MAX_REGISTER_SIZE];
 298   int regnum;
 299   /* The dst had better not be read-only.  If it is, the `restore'
 300      doesn't make much sense.  */
 301   gdb_assert (!dst->readonly_p);
 302   /* Copy over any registers, being careful to only restore those that
 303      were both saved and need to be restored.  The full [0 .. NUM_REGS
 304      + NUM_PSEUDO_REGS) range is checked since some architectures need
 305      to save/restore `cooked' registers that live in memory.  */
 306   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 307     {
 308       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 309         {
 310           int valid = cooked_read (cooked_read_context, regnum, buf);
 311           if (valid)
 312             regcache_cooked_write (dst, regnum, buf);
 313         }
 314     }
 315 }
 316
 317 static int
 318 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 319 {
 320   struct regcache *regcache = src;
 321   if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
 322     /* Don't even think about fetching a register from a read-only
 323        cache when the register isn't yet valid.  There isn't a target
 324        from which the register value can be fetched.  */
 325     return 0;
 326   regcache_cooked_read (regcache, regnum, buf);
 327   return 1;
 328 }
 329
 330
 331 void
 332 regcache_cpy (struct regcache *dst, struct regcache *src)
 333 {
 334   int i;
 335   gdb_byte *buf;
 336   gdb_assert (src != NULL && dst != NULL);
 337   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 338   gdb_assert (src != dst);
 339   gdb_assert (src->readonly_p || dst->readonly_p);
 340   if (!src->readonly_p)
 341     regcache_save (dst, do_cooked_read, src);
 342   else if (!dst->readonly_p)
 343     regcache_restore (dst, do_cooked_read, src);
 344   else
 345     regcache_cpy_no_passthrough (dst, src);
 346 }
 347
 348 void
 349 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 350 {
 351   int i;
 352   gdb_assert (src != NULL && dst != NULL);
 353   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 354   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 355      move of data into the current_regcache().  Doing this would be
 356      silly - it would mean that valid_p would be completely invalid.  */
 357   gdb_assert (dst != current_regcache);
 358   memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
 359   memcpy (dst->register_valid_p, src->register_valid_p,
 360           dst->descr->sizeof_raw_register_valid_p);
 361 }
 362
 363 struct regcache *
 364 regcache_dup (struct regcache *src)
 365 {
 366   struct regcache *newbuf;
 367   gdb_assert (current_regcache != NULL);
 368   newbuf = regcache_xmalloc (src->descr->gdbarch);
 369   regcache_cpy (newbuf, src);
 370   return newbuf;
 371 }
 372
 373 struct regcache *
 374 regcache_dup_no_passthrough (struct regcache *src)
 375 {
 376   struct regcache *newbuf;
 377   gdb_assert (current_regcache != NULL);
 378   newbuf = regcache_xmalloc (src->descr->gdbarch);
 379   regcache_cpy_no_passthrough (newbuf, src);
 380   return newbuf;
 381 }
 382
 383 int
 384 regcache_valid_p (const struct regcache *regcache, int regnum)
 385 {
 386   gdb_assert (regcache != NULL);
 387   gdb_assert (regnum >= 0);
 388   if (regcache->readonly_p)
 389     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 390   else
 391     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 392
 393   return regcache->register_valid_p[regnum];
 394 }
 395
 396 /* Global structure containing the current regcache.  */
 397 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
 398    deprecated_register_valid[] currently point into this structure.  */
 399 struct regcache *current_regcache;
 400
 401 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 402    recording if the register values have been changed (eg. by the
 403    user).  Therefore all registers must be written back to the
 404    target when appropriate.  */
 405
 406 /* The thread/process associated with the current set of registers. */
 407
 408 static ptid_t registers_ptid;
 409
 410 /*
 411  * FUNCTIONS:
 412  */
 413
 414 /* REGISTER_CACHED()
 415
 416    Returns 0 if the value is not in the cache (needs fetch).
 417           >0 if the value is in the cache.
 418           <0 if the value is permanently unavailable (don't ask again).  */
 419
 420 int
 421 register_cached (int regnum)
 422 {
 423   return current_regcache->register_valid_p[regnum];
 424 }
 425
 426 /* Record that REGNUM's value is cached if STATE is >0, uncached but
 427    fetchable if STATE is 0, and uncached and unfetchable if STATE is <0.  */
 428
 429 void
 430 set_register_cached (int regnum, int state)
 431 {
 432   gdb_assert (regnum >= 0);
 433   gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
 434   current_regcache->register_valid_p[regnum] = state;
 435 }
 436
 437 /* Observer for the target_changed event.  */
 438
 439 void
 440 regcache_observer_target_changed (struct target_ops *target)
 441 {
 442   registers_changed ();
 443 }
 444
 445 /* Low level examining and depositing of registers.
 446
 447    The caller is responsible for making sure that the inferior is
 448    stopped before calling the fetching routines, or it will get
 449    garbage.  (a change from GDB version 3, in which the caller got the
 450    value from the last stop).  */
 451
 452 /* REGISTERS_CHANGED ()
 453
 454    Indicate that registers may have changed, so invalidate the cache.  */
 455
 456 void
 457 registers_changed (void)
 458 {
 459   int i;
 460
 461   registers_ptid = pid_to_ptid (-1);
 462
 463   /* Force cleanup of any alloca areas if using C alloca instead of
 464      a builtin alloca.  This particular call is used to clean up
 465      areas allocated by low level target code which may build up
 466      during lengthy interactions between gdb and the target before
 467      gdb gives control to the user (ie watchpoints).  */
 468   alloca (0);
 469
 470   for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
 471     set_register_cached (i, 0);
 472 }
 473
 474 /* DEPRECATED_REGISTERS_FETCHED ()
 475
 476    Indicate that all registers have been fetched, so mark them all valid.  */
 477
 478 /* FIXME: cagney/2001-12-04: This function is DEPRECATED.  The target
 479    code was blatting the registers[] array and then calling this.
 480    Since targets should only be using regcache_raw_supply() the need for
 481    this function/hack is eliminated.  */
 482
 483 void
 484 deprecated_registers_fetched (void)
 485 {
 486   int i;
 487
 488   for (i = 0; i < NUM_REGS; i++)
 489     set_register_cached (i, 1);
 490   /* Do not assume that the pseudo-regs have also been fetched.
 491      Fetching all real regs NEVER accounts for pseudo-regs.  */
 492 }
 493
 494 void
 495 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 496 {
 497   gdb_assert (regcache != NULL && buf != NULL);
 498   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 499   /* Make certain that the register cache is up-to-date with respect
 500      to the current thread.  This switching shouldn't be necessary
 501      only there is still only one target side register cache.  Sigh!
 502      On the bright side, at least there is a regcache object.  */
 503   if (!regcache->readonly_p)
 504     {
 505       gdb_assert (regcache == current_regcache);
 506       if (! ptid_equal (registers_ptid, inferior_ptid))
 507         {
 508           registers_changed ();
 509           registers_ptid = inferior_ptid;
 510         }
 511       if (!regcache_valid_p (regcache, regnum))
 512         target_fetch_registers (regcache, regnum);
 513 #if 0
 514       /* FIXME: cagney/2004-08-07: At present a number of targets
 515          forget (or didn't know that they needed) to set this leading to
 516          panics.  Also is the problem that targets need to indicate
 517          that a register is in one of the possible states: valid,
 518          undefined, unknown.  The last of which isn't yet
 519          possible.  */
 520       gdb_assert (register_cached (regnum));
 521 #endif
 522     }
 523   /* Copy the value directly into the register cache.  */
 524   memcpy (buf, register_buffer (regcache, regnum),
 525           regcache->descr->sizeof_register[regnum]);
 526 }
 527
 528 void
 529 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 530 {
 531   gdb_byte *buf;
 532   gdb_assert (regcache != NULL);
 533   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 534   buf = alloca (regcache->descr->sizeof_register[regnum]);
 535   regcache_raw_read (regcache, regnum, buf);
 536   (*val) = extract_signed_integer (buf,
 537                                    regcache->descr->sizeof_register[regnum]);
 538 }
 539
 540 void
 541 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 542                             ULONGEST *val)
 543 {
 544   gdb_byte *buf;
 545   gdb_assert (regcache != NULL);
 546   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 547   buf = alloca (regcache->descr->sizeof_register[regnum]);
 548   regcache_raw_read (regcache, regnum, buf);
 549   (*val) = extract_unsigned_integer (buf,
 550                                      regcache->descr->sizeof_register[regnum]);
 551 }
 552
 553 void
 554 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 555 {
 556   void *buf;
 557   gdb_assert (regcache != NULL);
 558   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 559   buf = alloca (regcache->descr->sizeof_register[regnum]);
 560   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 561   regcache_raw_write (regcache, regnum, buf);
 562 }
 563
 564 void
 565 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 566                              ULONGEST val)
 567 {
 568   void *buf;
 569   gdb_assert (regcache != NULL);
 570   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 571   buf = alloca (regcache->descr->sizeof_register[regnum]);
 572   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 573   regcache_raw_write (regcache, regnum, buf);
 574 }
 575
 576 void
 577 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 578 {
 579   gdb_assert (regnum >= 0);
 580   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 581   if (regnum < regcache->descr->nr_raw_registers)
 582     regcache_raw_read (regcache, regnum, buf);
 583   else if (regcache->readonly_p
 584            && regnum < regcache->descr->nr_cooked_registers
 585            && regcache->register_valid_p[regnum])
 586     /* Read-only register cache, perhaps the cooked value was cached?  */
 587     memcpy (buf, register_buffer (regcache, regnum),
 588             regcache->descr->sizeof_register[regnum]);
 589   else
 590     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 591                                   regnum, buf);
 592 }
 593
 594 void
 595 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 596                              LONGEST *val)
 597 {
 598   gdb_byte *buf;
 599   gdb_assert (regcache != NULL);
 600   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 601   buf = alloca (regcache->descr->sizeof_register[regnum]);
 602   regcache_cooked_read (regcache, regnum, buf);
 603   (*val) = extract_signed_integer (buf,
 604                                    regcache->descr->sizeof_register[regnum]);
 605 }
 606
 607 void
 608 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 609                                ULONGEST *val)
 610 {
 611   gdb_byte *buf;
 612   gdb_assert (regcache != NULL);
 613   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 614   buf = alloca (regcache->descr->sizeof_register[regnum]);
 615   regcache_cooked_read (regcache, regnum, buf);
 616   (*val) = extract_unsigned_integer (buf,
 617                                      regcache->descr->sizeof_register[regnum]);
 618 }
 619
 620 void
 621 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 622                               LONGEST val)
 623 {
 624   void *buf;
 625   gdb_assert (regcache != NULL);
 626   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 627   buf = alloca (regcache->descr->sizeof_register[regnum]);
 628   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 629   regcache_cooked_write (regcache, regnum, buf);
 630 }
 631
 632 void
 633 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 634                                 ULONGEST val)
 635 {
 636   void *buf;
 637   gdb_assert (regcache != NULL);
 638   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 639   buf = alloca (regcache->descr->sizeof_register[regnum]);
 640   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 641   regcache_cooked_write (regcache, regnum, buf);
 642 }
 643
 644 void
 645 regcache_raw_write (struct regcache *regcache, int regnum,
 646                     const gdb_byte *buf)
 647 {
 648   gdb_assert (regcache != NULL && buf != NULL);
 649   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 650   gdb_assert (!regcache->readonly_p);
 651
 652   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 653      change the registers array if something writes to this register.  */
 654   if (CANNOT_STORE_REGISTER (regnum))
 655     return;
 656
 657   /* Make certain that the correct cache is selected.  */
 658   gdb_assert (regcache == current_regcache);
 659   if (! ptid_equal (registers_ptid, inferior_ptid))
 660     {
 661       registers_changed ();
 662       registers_ptid = inferior_ptid;
 663     }
 664
 665   /* If we have a valid copy of the register, and new value == old
 666      value, then don't bother doing the actual store. */
 667   if (regcache_valid_p (regcache, regnum)
 668       && (memcmp (register_buffer (regcache, regnum), buf,
 669                   regcache->descr->sizeof_register[regnum]) == 0))
 670     return;
 671
 672   target_prepare_to_store (regcache);
 673   memcpy (register_buffer (regcache, regnum), buf,
 674           regcache->descr->sizeof_register[regnum]);
 675   regcache->register_valid_p[regnum] = 1;
 676   target_store_registers (regcache, regnum);
 677 }
 678
 679 void
 680 regcache_cooked_write (struct regcache *regcache, int regnum,
 681                        const gdb_byte *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_write (regcache, regnum, buf);
 687   else
 688     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 689                                    regnum, buf);
 690 }
 691
 692 /* Perform a partial register transfer using a read, modify, write
 693    operation.  */
 694
 695 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 696                                     void *buf);
 697 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 698                                      const void *buf);
 699
 700 static void
 701 regcache_xfer_part (struct regcache *regcache, int regnum,
 702                     int offset, int len, void *in, const void *out,
 703                     void (*read) (struct regcache *regcache, int regnum,
 704                                   gdb_byte *buf),
 705                     void (*write) (struct regcache *regcache, int regnum,
 706                                    const gdb_byte *buf))
 707 {
 708   struct regcache_descr *descr = regcache->descr;
 709   gdb_byte reg[MAX_REGISTER_SIZE];
 710   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 711   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 712   /* Something to do?  */
 713   if (offset + len == 0)
 714     return;
 715   /* Read (when needed) ... */
 716   if (in != NULL
 717       || offset > 0
 718       || offset + len < descr->sizeof_register[regnum])
 719     {
 720       gdb_assert (read != NULL);
 721       read (regcache, regnum, reg);
 722     }
 723   /* ... modify ... */
 724   if (in != NULL)
 725     memcpy (in, reg + offset, len);
 726   if (out != NULL)
 727     memcpy (reg + offset, out, len);
 728   /* ... write (when needed).  */
 729   if (out != NULL)
 730     {
 731       gdb_assert (write != NULL);
 732       write (regcache, regnum, reg);
 733     }
 734 }
 735
 736 void
 737 regcache_raw_read_part (struct regcache *regcache, int regnum,
 738                         int offset, int len, gdb_byte *buf)
 739 {
 740   struct regcache_descr *descr = regcache->descr;
 741   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 742   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 743                       regcache_raw_read, regcache_raw_write);
 744 }
 745
 746 void
 747 regcache_raw_write_part (struct regcache *regcache, int regnum,
 748                          int offset, int len, const gdb_byte *buf)
 749 {
 750   struct regcache_descr *descr = regcache->descr;
 751   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 752   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 753                       regcache_raw_read, regcache_raw_write);
 754 }
 755
 756 void
 757 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 758                            int offset, int len, gdb_byte *buf)
 759 {
 760   struct regcache_descr *descr = regcache->descr;
 761   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 762   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 763                       regcache_cooked_read, regcache_cooked_write);
 764 }
 765
 766 void
 767 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 768                             int offset, int len, const gdb_byte *buf)
 769 {
 770   struct regcache_descr *descr = regcache->descr;
 771   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 772   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 773                       regcache_cooked_read, regcache_cooked_write);
 774 }
 775
 776 /* Hack to keep code that view the register buffer as raw bytes
 777    working.  */
 778
 779 int
 780 register_offset_hack (struct gdbarch *gdbarch, int regnum)
 781 {
 782   struct regcache_descr *descr = regcache_descr (gdbarch);
 783   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 784   return descr->register_offset[regnum];
 785 }
 786
 787 /* Return the contents of register REGNUM as an unsigned integer.  */
 788
 789 ULONGEST
 790 read_register (int regnum)
 791 {
 792   gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
 793   gdb_assert (current_regcache != NULL);
 794   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 795   regcache_cooked_read (current_regcache, regnum, buf);
 796   return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
 797 }
 798
 799 ULONGEST
 800 read_register_pid (int regnum, ptid_t ptid)
 801 {
 802   ptid_t save_ptid;
 803   int save_pid;
 804   CORE_ADDR retval;
 805
 806   if (ptid_equal (ptid, inferior_ptid))
 807     return read_register (regnum);
 808
 809   save_ptid = inferior_ptid;
 810
 811   inferior_ptid = ptid;
 812
 813   retval = read_register (regnum);
 814
 815   inferior_ptid = save_ptid;
 816
 817   return retval;
 818 }
 819
 820 /* Store VALUE into the raw contents of register number REGNUM.  */
 821
 822 void
 823 write_register (int regnum, LONGEST val)
 824 {
 825   void *buf;
 826   int size;
 827   size = register_size (current_gdbarch, regnum);
 828   buf = alloca (size);
 829   store_signed_integer (buf, size, (LONGEST) val);
 830   gdb_assert (current_regcache != NULL);
 831   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 832   regcache_cooked_write (current_regcache, regnum, buf);
 833 }
 834
 835 void
 836 write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
 837 {
 838   ptid_t save_ptid;
 839
 840   if (ptid_equal (ptid, inferior_ptid))
 841     {
 842       write_register (regnum, val);
 843       return;
 844     }
 845
 846   save_ptid = inferior_ptid;
 847
 848   inferior_ptid = ptid;
 849
 850   write_register (regnum, val);
 851
 852   inferior_ptid = save_ptid;
 853 }
 854
 855 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 856
 857 void
 858 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 859 {
 860   void *regbuf;
 861   size_t size;
 862
 863   gdb_assert (regcache != NULL);
 864   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 865   gdb_assert (!regcache->readonly_p);
 866
 867   /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
 868      CURRENT_REGCACHE specially here.  */
 869   if (regcache == current_regcache
 870       && !ptid_equal (registers_ptid, inferior_ptid))
 871     {
 872       registers_changed ();
 873       registers_ptid = inferior_ptid;
 874     }
 875
 876   regbuf = register_buffer (regcache, regnum);
 877   size = regcache->descr->sizeof_register[regnum];
 878
 879   if (buf)
 880     memcpy (regbuf, buf, size);
 881   else
 882     memset (regbuf, 0, size);
 883
 884   /* Mark the register as cached.  */
 885   regcache->register_valid_p[regnum] = 1;
 886 }
 887
 888 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 889
 890 void
 891 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 892 {
 893   const void *regbuf;
 894   size_t size;
 895
 896   gdb_assert (regcache != NULL && buf != NULL);
 897   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 898
 899   regbuf = register_buffer (regcache, regnum);
 900   size = regcache->descr->sizeof_register[regnum];
 901   memcpy (buf, regbuf, size);
 902 }
 903
 904
 905 /* read_pc, write_pc, read_sp, etc.  Special handling for registers
 906    PC, SP, and FP.  */
 907
 908 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
 909    read_sp(), will eventually be replaced by per-frame methods.
 910    Instead of relying on the global INFERIOR_PTID, they will use the
 911    contextual information provided by the FRAME.  These functions do
 912    not belong in the register cache.  */
 913
 914 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
 915    write_pc_pid() and write_pc(), all need to be replaced by something
 916    that does not rely on global state.  But what?  */
 917
 918 CORE_ADDR
 919 read_pc_pid (ptid_t ptid)
 920 {
 921   ptid_t saved_inferior_ptid;
 922   CORE_ADDR pc_val;
 923
 924   /* In case ptid != inferior_ptid. */
 925   saved_inferior_ptid = inferior_ptid;
 926   inferior_ptid = ptid;
 927
 928   if (TARGET_READ_PC_P ())
 929     pc_val = TARGET_READ_PC (ptid);
 930   /* Else use per-frame method on get_current_frame.  */
 931   else if (PC_REGNUM >= 0)
 932     {
 933       CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
 934       pc_val = ADDR_BITS_REMOVE (raw_val);
 935     }
 936   else
 937     internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
 938
 939   inferior_ptid = saved_inferior_ptid;
 940   return pc_val;
 941 }
 942
 943 CORE_ADDR
 944 read_pc (void)
 945 {
 946   return read_pc_pid (inferior_ptid);
 947 }
 948
 949 void
 950 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
 951 {
 952   if (PC_REGNUM >= 0)
 953     write_register_pid (PC_REGNUM, pc, ptid);
 954   else
 955     internal_error (__FILE__, __LINE__,
 956                     _("generic_target_write_pc"));
 957 }
 958
 959 void
 960 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
 961 {
 962   ptid_t saved_inferior_ptid;
 963
 964   /* In case ptid != inferior_ptid. */
 965   saved_inferior_ptid = inferior_ptid;
 966   inferior_ptid = ptid;
 967
 968   TARGET_WRITE_PC (pc, ptid);
 969
 970   inferior_ptid = saved_inferior_ptid;
 971 }
 972
 973 void
 974 write_pc (CORE_ADDR pc)
 975 {
 976   write_pc_pid (pc, inferior_ptid);
 977 }
 978
 979 /* Cope with strage ways of getting to the stack and frame pointers */
 980
 981 CORE_ADDR
 982 read_sp (void)
 983 {
 984   if (TARGET_READ_SP_P ())
 985     return TARGET_READ_SP ();
 986   else if (gdbarch_unwind_sp_p (current_gdbarch))
 987     return get_frame_sp (get_current_frame ());
 988   else if (SP_REGNUM >= 0)
 989     /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
 990        about the architecture so put it at the end.  */
 991     return read_register (SP_REGNUM);
 992   internal_error (__FILE__, __LINE__, _("read_sp: Unable to find SP"));
 993 }
 994
 995 static void
 996 reg_flush_command (char *command, int from_tty)
 997 {
 998   /* Force-flush the register cache.  */
 999   registers_changed ();
1000   if (from_tty)
1001     printf_filtered (_("Register cache flushed.\n"));
1002 }
1003
1004 static void
1005 build_regcache (void)
1006 {
1007   current_regcache = regcache_xmalloc (current_gdbarch);
1008   current_regcache->readonly_p = 0;
1009 }
1010
1011 static void
1012 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1013                    const unsigned char *buf, long len)
1014 {
1015   int i;
1016   switch (endian)
1017     {
1018     case BFD_ENDIAN_BIG:
1019       for (i = 0; i < len; i++)
1020         fprintf_unfiltered (file, "%02x", buf[i]);
1021       break;
1022     case BFD_ENDIAN_LITTLE:
1023       for (i = len - 1; i >= 0; i--)
1024         fprintf_unfiltered (file, "%02x", buf[i]);
1025       break;
1026     default:
1027       internal_error (__FILE__, __LINE__, _("Bad switch"));
1028     }
1029 }
1030
1031 enum regcache_dump_what
1032 {
1033   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1034 };
1035
1036 static void
1037 regcache_dump (struct regcache *regcache, struct ui_file *file,
1038                enum regcache_dump_what what_to_dump)
1039 {
1040   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1041   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1042   int regnum;
1043   int footnote_nr = 0;
1044   int footnote_register_size = 0;
1045   int footnote_register_offset = 0;
1046   int footnote_register_type_name_null = 0;
1047   long register_offset = 0;
1048   unsigned char buf[MAX_REGISTER_SIZE];
1049
1050 #if 0
1051   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1052                       regcache->descr->nr_raw_registers);
1053   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1054                       regcache->descr->nr_cooked_registers);
1055   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1056                       regcache->descr->sizeof_raw_registers);
1057   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1058                       regcache->descr->sizeof_raw_register_valid_p);
1059   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1060   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1061 #endif
1062
1063   gdb_assert (regcache->descr->nr_cooked_registers
1064               == (NUM_REGS + NUM_PSEUDO_REGS));
1065
1066   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1067     {
1068       /* Name.  */
1069       if (regnum < 0)
1070         fprintf_unfiltered (file, " %-10s", "Name");
1071       else
1072         {
1073           const char *p = REGISTER_NAME (regnum);
1074           if (p == NULL)
1075             p = "";
1076           else if (p[0] == '\0')
1077             p = "''";
1078           fprintf_unfiltered (file, " %-10s", p);
1079         }
1080
1081       /* Number.  */
1082       if (regnum < 0)
1083         fprintf_unfiltered (file, " %4s", "Nr");
1084       else
1085         fprintf_unfiltered (file, " %4d", regnum);
1086
1087       /* Relative number.  */
1088       if (regnum < 0)
1089         fprintf_unfiltered (file, " %4s", "Rel");
1090       else if (regnum < NUM_REGS)
1091         fprintf_unfiltered (file, " %4d", regnum);
1092       else
1093         fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1094
1095       /* Offset.  */
1096       if (regnum < 0)
1097         fprintf_unfiltered (file, " %6s  ", "Offset");
1098       else
1099         {
1100           fprintf_unfiltered (file, " %6ld",
1101                               regcache->descr->register_offset[regnum]);
1102           if (register_offset != regcache->descr->register_offset[regnum]
1103               || (regnum > 0
1104                   && (regcache->descr->register_offset[regnum]
1105                       != (regcache->descr->register_offset[regnum - 1]
1106                           + regcache->descr->sizeof_register[regnum - 1])))
1107               )
1108             {
1109               if (!footnote_register_offset)
1110                 footnote_register_offset = ++footnote_nr;
1111               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1112             }
1113           else
1114             fprintf_unfiltered (file, "  ");
1115           register_offset = (regcache->descr->register_offset[regnum]
1116                              + regcache->descr->sizeof_register[regnum]);
1117         }
1118
1119       /* Size.  */
1120       if (regnum < 0)
1121         fprintf_unfiltered (file, " %5s ", "Size");
1122       else
1123         fprintf_unfiltered (file, " %5ld",
1124                             regcache->descr->sizeof_register[regnum]);
1125
1126       /* Type.  */
1127       {
1128         const char *t;
1129         if (regnum < 0)
1130           t = "Type";
1131         else
1132           {
1133             static const char blt[] = "builtin_type";
1134             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1135             if (t == NULL)
1136               {
1137                 char *n;
1138                 if (!footnote_register_type_name_null)
1139                   footnote_register_type_name_null = ++footnote_nr;
1140                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1141                 make_cleanup (xfree, n);
1142                 t = n;
1143               }
1144             /* Chop a leading builtin_type.  */
1145             if (strncmp (t, blt, strlen (blt)) == 0)
1146               t += strlen (blt);
1147           }
1148         fprintf_unfiltered (file, " %-15s", t);
1149       }
1150
1151       /* Leading space always present.  */
1152       fprintf_unfiltered (file, " ");
1153
1154       /* Value, raw.  */
1155       if (what_to_dump == regcache_dump_raw)
1156         {
1157           if (regnum < 0)
1158             fprintf_unfiltered (file, "Raw value");
1159           else if (regnum >= regcache->descr->nr_raw_registers)
1160             fprintf_unfiltered (file, "<cooked>");
1161           else if (!regcache_valid_p (regcache, regnum))
1162             fprintf_unfiltered (file, "<invalid>");
1163           else
1164             {
1165               regcache_raw_read (regcache, regnum, buf);
1166               fprintf_unfiltered (file, "0x");
1167               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1168                                  regcache->descr->sizeof_register[regnum]);
1169             }
1170         }
1171
1172       /* Value, cooked.  */
1173       if (what_to_dump == regcache_dump_cooked)
1174         {
1175           if (regnum < 0)
1176             fprintf_unfiltered (file, "Cooked value");
1177           else
1178             {
1179               regcache_cooked_read (regcache, regnum, buf);
1180               fprintf_unfiltered (file, "0x");
1181               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1182                                  regcache->descr->sizeof_register[regnum]);
1183             }
1184         }
1185
1186       /* Group members.  */
1187       if (what_to_dump == regcache_dump_groups)
1188         {
1189           if (regnum < 0)
1190             fprintf_unfiltered (file, "Groups");
1191           else
1192             {
1193               const char *sep = "";
1194               struct reggroup *group;
1195               for (group = reggroup_next (gdbarch, NULL);
1196                    group != NULL;
1197                    group = reggroup_next (gdbarch, group))
1198                 {
1199                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1200                     {
1201                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1202                       sep = ",";
1203                     }
1204                 }
1205             }
1206         }
1207
1208       fprintf_unfiltered (file, "\n");
1209     }
1210
1211   if (footnote_register_size)
1212     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1213                         footnote_register_size);
1214   if (footnote_register_offset)
1215     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1216                         footnote_register_offset);
1217   if (footnote_register_type_name_null)
1218     fprintf_unfiltered (file,
1219                         "*%d: Register type's name NULL.\n",
1220                         footnote_register_type_name_null);
1221   do_cleanups (cleanups);
1222 }
1223
1224 static void
1225 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1226 {
1227   if (args == NULL)
1228     regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1229   else
1230     {
1231       struct ui_file *file = gdb_fopen (args, "w");
1232       if (file == NULL)
1233         perror_with_name (_("maintenance print architecture"));
1234       regcache_dump (current_regcache, file, what_to_dump);
1235       ui_file_delete (file);
1236     }
1237 }
1238
1239 static void
1240 maintenance_print_registers (char *args, int from_tty)
1241 {
1242   regcache_print (args, regcache_dump_none);
1243 }
1244
1245 static void
1246 maintenance_print_raw_registers (char *args, int from_tty)
1247 {
1248   regcache_print (args, regcache_dump_raw);
1249 }
1250
1251 static void
1252 maintenance_print_cooked_registers (char *args, int from_tty)
1253 {
1254   regcache_print (args, regcache_dump_cooked);
1255 }
1256
1257 static void
1258 maintenance_print_register_groups (char *args, int from_tty)
1259 {
1260   regcache_print (args, regcache_dump_groups);
1261 }
1262
1263 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1264
1265 void
1266 _initialize_regcache (void)
1267 {
1268   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1269   DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1270   deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1271
1272   observer_attach_target_changed (regcache_observer_target_changed);
1273
1274   add_com ("flushregs", class_maintenance, reg_flush_command,
1275            _("Force gdb to flush its register cache (maintainer command)"));
1276
1277    /* Initialize the thread/process associated with the current set of
1278       registers.  For now, -1 is special, and means `no current process'.  */
1279   registers_ptid = pid_to_ptid (-1);
1280
1281   add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1282 Print the internal register configuration.\n\
1283 Takes an optional file parameter."), &maintenanceprintlist);
1284   add_cmd ("raw-registers", class_maintenance,
1285            maintenance_print_raw_registers, _("\
1286 Print the internal register configuration including raw values.\n\
1287 Takes an optional file parameter."), &maintenanceprintlist);
1288   add_cmd ("cooked-registers", class_maintenance,
1289            maintenance_print_cooked_registers, _("\
1290 Print the internal register configuration including cooked values.\n\
1291 Takes an optional file parameter."), &maintenanceprintlist);
1292   add_cmd ("register-groups", class_maintenance,
1293            maintenance_print_register_groups, _("\
1294 Print the internal register configuration including each register's group.\n\
1295 Takes an optional file parameter."),
1296            &maintenanceprintlist);
1297
1298 }