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 (!register_cached (regnum))
 512         target_fetch_registers (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 deprecated_read_register_gen (int regnum, gdb_byte *buf)
 578 {
 579   gdb_assert (current_regcache != NULL);
 580   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 581   regcache_cooked_read (current_regcache, regnum, buf);
 582 }
 583
 584 void
 585 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 586 {
 587   gdb_assert (regnum >= 0);
 588   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 589   if (regnum < regcache->descr->nr_raw_registers)
 590     regcache_raw_read (regcache, regnum, buf);
 591   else if (regcache->readonly_p
 592            && regnum < regcache->descr->nr_cooked_registers
 593            && regcache->register_valid_p[regnum])
 594     /* Read-only register cache, perhaps the cooked value was cached?  */
 595     memcpy (buf, register_buffer (regcache, regnum),
 596             regcache->descr->sizeof_register[regnum]);
 597   else
 598     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 599                                   regnum, buf);
 600 }
 601
 602 void
 603 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 604                              LONGEST *val)
 605 {
 606   gdb_byte *buf;
 607   gdb_assert (regcache != NULL);
 608   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 609   buf = alloca (regcache->descr->sizeof_register[regnum]);
 610   regcache_cooked_read (regcache, regnum, buf);
 611   (*val) = extract_signed_integer (buf,
 612                                    regcache->descr->sizeof_register[regnum]);
 613 }
 614
 615 void
 616 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 617                                ULONGEST *val)
 618 {
 619   gdb_byte *buf;
 620   gdb_assert (regcache != NULL);
 621   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 622   buf = alloca (regcache->descr->sizeof_register[regnum]);
 623   regcache_cooked_read (regcache, regnum, buf);
 624   (*val) = extract_unsigned_integer (buf,
 625                                      regcache->descr->sizeof_register[regnum]);
 626 }
 627
 628 void
 629 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 630                               LONGEST val)
 631 {
 632   void *buf;
 633   gdb_assert (regcache != NULL);
 634   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 635   buf = alloca (regcache->descr->sizeof_register[regnum]);
 636   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 637   regcache_cooked_write (regcache, regnum, buf);
 638 }
 639
 640 void
 641 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 642                                 ULONGEST val)
 643 {
 644   void *buf;
 645   gdb_assert (regcache != NULL);
 646   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 647   buf = alloca (regcache->descr->sizeof_register[regnum]);
 648   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 649   regcache_cooked_write (regcache, regnum, buf);
 650 }
 651
 652 void
 653 regcache_raw_write (struct regcache *regcache, int regnum,
 654                     const gdb_byte *buf)
 655 {
 656   gdb_assert (regcache != NULL && buf != NULL);
 657   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 658   gdb_assert (!regcache->readonly_p);
 659
 660   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 661      change the registers array if something writes to this register.  */
 662   if (CANNOT_STORE_REGISTER (regnum))
 663     return;
 664
 665   /* Make certain that the correct cache is selected.  */
 666   gdb_assert (regcache == current_regcache);
 667   if (! ptid_equal (registers_ptid, inferior_ptid))
 668     {
 669       registers_changed ();
 670       registers_ptid = inferior_ptid;
 671     }
 672
 673   /* If we have a valid copy of the register, and new value == old
 674      value, then don't bother doing the actual store. */
 675   if (regcache_valid_p (regcache, regnum)
 676       && (memcmp (register_buffer (regcache, regnum), buf,
 677                   regcache->descr->sizeof_register[regnum]) == 0))
 678     return;
 679
 680   target_prepare_to_store ();
 681   memcpy (register_buffer (regcache, regnum), buf,
 682           regcache->descr->sizeof_register[regnum]);
 683   regcache->register_valid_p[regnum] = 1;
 684   target_store_registers (regnum);
 685 }
 686
 687 void
 688 deprecated_write_register_gen (int regnum, gdb_byte *buf)
 689 {
 690   gdb_assert (current_regcache != NULL);
 691   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 692   regcache_cooked_write (current_regcache, regnum, buf);
 693 }
 694
 695 void
 696 regcache_cooked_write (struct regcache *regcache, int regnum,
 697                        const gdb_byte *buf)
 698 {
 699   gdb_assert (regnum >= 0);
 700   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 701   if (regnum < regcache->descr->nr_raw_registers)
 702     regcache_raw_write (regcache, regnum, buf);
 703   else
 704     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 705                                    regnum, buf);
 706 }
 707
 708 /* Perform a partial register transfer using a read, modify, write
 709    operation.  */
 710
 711 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 712                                     void *buf);
 713 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 714                                      const void *buf);
 715
 716 static void
 717 regcache_xfer_part (struct regcache *regcache, int regnum,
 718                     int offset, int len, void *in, const void *out,
 719                     void (*read) (struct regcache *regcache, int regnum,
 720                                   gdb_byte *buf),
 721                     void (*write) (struct regcache *regcache, int regnum,
 722                                    const gdb_byte *buf))
 723 {
 724   struct regcache_descr *descr = regcache->descr;
 725   gdb_byte reg[MAX_REGISTER_SIZE];
 726   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 727   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 728   /* Something to do?  */
 729   if (offset + len == 0)
 730     return;
 731   /* Read (when needed) ... */
 732   if (in != NULL
 733       || offset > 0
 734       || offset + len < descr->sizeof_register[regnum])
 735     {
 736       gdb_assert (read != NULL);
 737       read (regcache, regnum, reg);
 738     }
 739   /* ... modify ... */
 740   if (in != NULL)
 741     memcpy (in, reg + offset, len);
 742   if (out != NULL)
 743     memcpy (reg + offset, out, len);
 744   /* ... write (when needed).  */
 745   if (out != NULL)
 746     {
 747       gdb_assert (write != NULL);
 748       write (regcache, regnum, reg);
 749     }
 750 }
 751
 752 void
 753 regcache_raw_read_part (struct regcache *regcache, int regnum,
 754                         int offset, int len, gdb_byte *buf)
 755 {
 756   struct regcache_descr *descr = regcache->descr;
 757   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 758   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 759                       regcache_raw_read, regcache_raw_write);
 760 }
 761
 762 void
 763 regcache_raw_write_part (struct regcache *regcache, int regnum,
 764                          int offset, int len, const gdb_byte *buf)
 765 {
 766   struct regcache_descr *descr = regcache->descr;
 767   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 768   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 769                       regcache_raw_read, regcache_raw_write);
 770 }
 771
 772 void
 773 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 774                            int offset, int len, gdb_byte *buf)
 775 {
 776   struct regcache_descr *descr = regcache->descr;
 777   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 778   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 779                       regcache_cooked_read, regcache_cooked_write);
 780 }
 781
 782 void
 783 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 784                             int offset, int len, const gdb_byte *buf)
 785 {
 786   struct regcache_descr *descr = regcache->descr;
 787   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 788   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 789                       regcache_cooked_read, regcache_cooked_write);
 790 }
 791
 792 /* Hack to keep code that view the register buffer as raw bytes
 793    working.  */
 794
 795 int
 796 register_offset_hack (struct gdbarch *gdbarch, int regnum)
 797 {
 798   struct regcache_descr *descr = regcache_descr (gdbarch);
 799   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 800   return descr->register_offset[regnum];
 801 }
 802
 803 /* Return the contents of register REGNUM as an unsigned integer.  */
 804
 805 ULONGEST
 806 read_register (int regnum)
 807 {
 808   gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
 809   deprecated_read_register_gen (regnum, buf);
 810   return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
 811 }
 812
 813 ULONGEST
 814 read_register_pid (int regnum, ptid_t ptid)
 815 {
 816   ptid_t save_ptid;
 817   int save_pid;
 818   CORE_ADDR retval;
 819
 820   if (ptid_equal (ptid, inferior_ptid))
 821     return read_register (regnum);
 822
 823   save_ptid = inferior_ptid;
 824
 825   inferior_ptid = ptid;
 826
 827   retval = read_register (regnum);
 828
 829   inferior_ptid = save_ptid;
 830
 831   return retval;
 832 }
 833
 834 /* Store VALUE into the raw contents of register number REGNUM.  */
 835
 836 void
 837 write_register (int regnum, LONGEST val)
 838 {
 839   void *buf;
 840   int size;
 841   size = register_size (current_gdbarch, regnum);
 842   buf = alloca (size);
 843   store_signed_integer (buf, size, (LONGEST) val);
 844   deprecated_write_register_gen (regnum, buf);
 845 }
 846
 847 void
 848 write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
 849 {
 850   ptid_t save_ptid;
 851
 852   if (ptid_equal (ptid, inferior_ptid))
 853     {
 854       write_register (regnum, val);
 855       return;
 856     }
 857
 858   save_ptid = inferior_ptid;
 859
 860   inferior_ptid = ptid;
 861
 862   write_register (regnum, val);
 863
 864   inferior_ptid = save_ptid;
 865 }
 866
 867 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 868
 869 void
 870 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 871 {
 872   void *regbuf;
 873   size_t size;
 874
 875   gdb_assert (regcache != NULL);
 876   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 877   gdb_assert (!regcache->readonly_p);
 878
 879   /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
 880      CURRENT_REGCACHE specially here.  */
 881   if (regcache == current_regcache
 882       && !ptid_equal (registers_ptid, inferior_ptid))
 883     {
 884       registers_changed ();
 885       registers_ptid = inferior_ptid;
 886     }
 887
 888   regbuf = register_buffer (regcache, regnum);
 889   size = regcache->descr->sizeof_register[regnum];
 890
 891   if (buf)
 892     memcpy (regbuf, buf, size);
 893   else
 894     memset (regbuf, 0, size);
 895
 896   /* Mark the register as cached.  */
 897   regcache->register_valid_p[regnum] = 1;
 898 }
 899
 900 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 901
 902 void
 903 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 904 {
 905   const void *regbuf;
 906   size_t size;
 907
 908   gdb_assert (regcache != NULL && buf != NULL);
 909   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 910
 911   regbuf = register_buffer (regcache, regnum);
 912   size = regcache->descr->sizeof_register[regnum];
 913   memcpy (buf, regbuf, size);
 914 }
 915
 916
 917 /* read_pc, write_pc, read_sp, etc.  Special handling for registers
 918    PC, SP, and FP.  */
 919
 920 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
 921    read_sp(), will eventually be replaced by per-frame methods.
 922    Instead of relying on the global INFERIOR_PTID, they will use the
 923    contextual information provided by the FRAME.  These functions do
 924    not belong in the register cache.  */
 925
 926 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
 927    write_pc_pid() and write_pc(), all need to be replaced by something
 928    that does not rely on global state.  But what?  */
 929
 930 CORE_ADDR
 931 read_pc_pid (ptid_t ptid)
 932 {
 933   ptid_t saved_inferior_ptid;
 934   CORE_ADDR pc_val;
 935
 936   /* In case ptid != inferior_ptid. */
 937   saved_inferior_ptid = inferior_ptid;
 938   inferior_ptid = ptid;
 939
 940   if (TARGET_READ_PC_P ())
 941     pc_val = TARGET_READ_PC (ptid);
 942   /* Else use per-frame method on get_current_frame.  */
 943   else if (PC_REGNUM >= 0)
 944     {
 945       CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
 946       pc_val = ADDR_BITS_REMOVE (raw_val);
 947     }
 948   else
 949     internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
 950
 951   inferior_ptid = saved_inferior_ptid;
 952   return pc_val;
 953 }
 954
 955 CORE_ADDR
 956 read_pc (void)
 957 {
 958   return read_pc_pid (inferior_ptid);
 959 }
 960
 961 void
 962 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
 963 {
 964   if (PC_REGNUM >= 0)
 965     write_register_pid (PC_REGNUM, pc, ptid);
 966   else
 967     internal_error (__FILE__, __LINE__,
 968                     _("generic_target_write_pc"));
 969 }
 970
 971 void
 972 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
 973 {
 974   ptid_t saved_inferior_ptid;
 975
 976   /* In case ptid != inferior_ptid. */
 977   saved_inferior_ptid = inferior_ptid;
 978   inferior_ptid = ptid;
 979
 980   TARGET_WRITE_PC (pc, ptid);
 981
 982   inferior_ptid = saved_inferior_ptid;
 983 }
 984
 985 void
 986 write_pc (CORE_ADDR pc)
 987 {
 988   write_pc_pid (pc, inferior_ptid);
 989 }
 990
 991 /* Cope with strage ways of getting to the stack and frame pointers */
 992
 993 CORE_ADDR
 994 read_sp (void)
 995 {
 996   if (TARGET_READ_SP_P ())
 997     return TARGET_READ_SP ();
 998   else if (gdbarch_unwind_sp_p (current_gdbarch))
 999     return get_frame_sp (get_current_frame ());
1000   else if (SP_REGNUM >= 0)
1001     /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1002        about the architecture so put it at the end.  */
1003     return read_register (SP_REGNUM);
1004   internal_error (__FILE__, __LINE__, _("read_sp: Unable to find SP"));
1005 }
1006
1007 static void
1008 reg_flush_command (char *command, int from_tty)
1009 {
1010   /* Force-flush the register cache.  */
1011   registers_changed ();
1012   if (from_tty)
1013     printf_filtered (_("Register cache flushed.\n"));
1014 }
1015
1016 static void
1017 build_regcache (void)
1018 {
1019   current_regcache = regcache_xmalloc (current_gdbarch);
1020   current_regcache->readonly_p = 0;
1021 }
1022
1023 static void
1024 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1025                    const unsigned char *buf, long len)
1026 {
1027   int i;
1028   switch (endian)
1029     {
1030     case BFD_ENDIAN_BIG:
1031       for (i = 0; i < len; i++)
1032         fprintf_unfiltered (file, "%02x", buf[i]);
1033       break;
1034     case BFD_ENDIAN_LITTLE:
1035       for (i = len - 1; i >= 0; i--)
1036         fprintf_unfiltered (file, "%02x", buf[i]);
1037       break;
1038     default:
1039       internal_error (__FILE__, __LINE__, _("Bad switch"));
1040     }
1041 }
1042
1043 enum regcache_dump_what
1044 {
1045   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1046 };
1047
1048 static void
1049 regcache_dump (struct regcache *regcache, struct ui_file *file,
1050                enum regcache_dump_what what_to_dump)
1051 {
1052   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1053   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1054   int regnum;
1055   int footnote_nr = 0;
1056   int footnote_register_size = 0;
1057   int footnote_register_offset = 0;
1058   int footnote_register_type_name_null = 0;
1059   long register_offset = 0;
1060   unsigned char buf[MAX_REGISTER_SIZE];
1061
1062 #if 0
1063   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1064                       regcache->descr->nr_raw_registers);
1065   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1066                       regcache->descr->nr_cooked_registers);
1067   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1068                       regcache->descr->sizeof_raw_registers);
1069   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1070                       regcache->descr->sizeof_raw_register_valid_p);
1071   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1072   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1073 #endif
1074
1075   gdb_assert (regcache->descr->nr_cooked_registers
1076               == (NUM_REGS + NUM_PSEUDO_REGS));
1077
1078   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1079     {
1080       /* Name.  */
1081       if (regnum < 0)
1082         fprintf_unfiltered (file, " %-10s", "Name");
1083       else
1084         {
1085           const char *p = REGISTER_NAME (regnum);
1086           if (p == NULL)
1087             p = "";
1088           else if (p[0] == '\0')
1089             p = "''";
1090           fprintf_unfiltered (file, " %-10s", p);
1091         }
1092
1093       /* Number.  */
1094       if (regnum < 0)
1095         fprintf_unfiltered (file, " %4s", "Nr");
1096       else
1097         fprintf_unfiltered (file, " %4d", regnum);
1098
1099       /* Relative number.  */
1100       if (regnum < 0)
1101         fprintf_unfiltered (file, " %4s", "Rel");
1102       else if (regnum < NUM_REGS)
1103         fprintf_unfiltered (file, " %4d", regnum);
1104       else
1105         fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1106
1107       /* Offset.  */
1108       if (regnum < 0)
1109         fprintf_unfiltered (file, " %6s  ", "Offset");
1110       else
1111         {
1112           fprintf_unfiltered (file, " %6ld",
1113                               regcache->descr->register_offset[regnum]);
1114           if (register_offset != regcache->descr->register_offset[regnum]
1115               || (regnum > 0
1116                   && (regcache->descr->register_offset[regnum]
1117                       != (regcache->descr->register_offset[regnum - 1]
1118                           + regcache->descr->sizeof_register[regnum - 1])))
1119               )
1120             {
1121               if (!footnote_register_offset)
1122                 footnote_register_offset = ++footnote_nr;
1123               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1124             }
1125           else
1126             fprintf_unfiltered (file, "  ");
1127           register_offset = (regcache->descr->register_offset[regnum]
1128                              + regcache->descr->sizeof_register[regnum]);
1129         }
1130
1131       /* Size.  */
1132       if (regnum < 0)
1133         fprintf_unfiltered (file, " %5s ", "Size");
1134       else
1135         fprintf_unfiltered (file, " %5ld",
1136                             regcache->descr->sizeof_register[regnum]);
1137
1138       /* Type.  */
1139       {
1140         const char *t;
1141         if (regnum < 0)
1142           t = "Type";
1143         else
1144           {
1145             static const char blt[] = "builtin_type";
1146             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1147             if (t == NULL)
1148               {
1149                 char *n;
1150                 if (!footnote_register_type_name_null)
1151                   footnote_register_type_name_null = ++footnote_nr;
1152                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1153                 make_cleanup (xfree, n);
1154                 t = n;
1155               }
1156             /* Chop a leading builtin_type.  */
1157             if (strncmp (t, blt, strlen (blt)) == 0)
1158               t += strlen (blt);
1159           }
1160         fprintf_unfiltered (file, " %-15s", t);
1161       }
1162
1163       /* Leading space always present.  */
1164       fprintf_unfiltered (file, " ");
1165
1166       /* Value, raw.  */
1167       if (what_to_dump == regcache_dump_raw)
1168         {
1169           if (regnum < 0)
1170             fprintf_unfiltered (file, "Raw value");
1171           else if (regnum >= regcache->descr->nr_raw_registers)
1172             fprintf_unfiltered (file, "<cooked>");
1173           else if (!regcache_valid_p (regcache, regnum))
1174             fprintf_unfiltered (file, "<invalid>");
1175           else
1176             {
1177               regcache_raw_read (regcache, regnum, buf);
1178               fprintf_unfiltered (file, "0x");
1179               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1180                                  regcache->descr->sizeof_register[regnum]);
1181             }
1182         }
1183
1184       /* Value, cooked.  */
1185       if (what_to_dump == regcache_dump_cooked)
1186         {
1187           if (regnum < 0)
1188             fprintf_unfiltered (file, "Cooked value");
1189           else
1190             {
1191               regcache_cooked_read (regcache, regnum, buf);
1192               fprintf_unfiltered (file, "0x");
1193               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1194                                  regcache->descr->sizeof_register[regnum]);
1195             }
1196         }
1197
1198       /* Group members.  */
1199       if (what_to_dump == regcache_dump_groups)
1200         {
1201           if (regnum < 0)
1202             fprintf_unfiltered (file, "Groups");
1203           else
1204             {
1205               const char *sep = "";
1206               struct reggroup *group;
1207               for (group = reggroup_next (gdbarch, NULL);
1208                    group != NULL;
1209                    group = reggroup_next (gdbarch, group))
1210                 {
1211                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1212                     {
1213                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1214                       sep = ",";
1215                     }
1216                 }
1217             }
1218         }
1219
1220       fprintf_unfiltered (file, "\n");
1221     }
1222
1223   if (footnote_register_size)
1224     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1225                         footnote_register_size);
1226   if (footnote_register_offset)
1227     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1228                         footnote_register_offset);
1229   if (footnote_register_type_name_null)
1230     fprintf_unfiltered (file,
1231                         "*%d: Register type's name NULL.\n",
1232                         footnote_register_type_name_null);
1233   do_cleanups (cleanups);
1234 }
1235
1236 static void
1237 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1238 {
1239   if (args == NULL)
1240     regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1241   else
1242     {
1243       struct ui_file *file = gdb_fopen (args, "w");
1244       if (file == NULL)
1245         perror_with_name (_("maintenance print architecture"));
1246       regcache_dump (current_regcache, file, what_to_dump);
1247       ui_file_delete (file);
1248     }
1249 }
1250
1251 static void
1252 maintenance_print_registers (char *args, int from_tty)
1253 {
1254   regcache_print (args, regcache_dump_none);
1255 }
1256
1257 static void
1258 maintenance_print_raw_registers (char *args, int from_tty)
1259 {
1260   regcache_print (args, regcache_dump_raw);
1261 }
1262
1263 static void
1264 maintenance_print_cooked_registers (char *args, int from_tty)
1265 {
1266   regcache_print (args, regcache_dump_cooked);
1267 }
1268
1269 static void
1270 maintenance_print_register_groups (char *args, int from_tty)
1271 {
1272   regcache_print (args, regcache_dump_groups);
1273 }
1274
1275 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1276
1277 void
1278 _initialize_regcache (void)
1279 {
1280   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1281   DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1282   deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1283
1284   observer_attach_target_changed (regcache_observer_target_changed);
1285
1286   add_com ("flushregs", class_maintenance, reg_flush_command,
1287            _("Force gdb to flush its register cache (maintainer command)"));
1288
1289    /* Initialize the thread/process associated with the current set of
1290       registers.  For now, -1 is special, and means `no current process'.  */
1291   registers_ptid = pid_to_ptid (-1);
1292
1293   add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1294 Print the internal register configuration.\n\
1295 Takes an optional file parameter."), &maintenanceprintlist);
1296   add_cmd ("raw-registers", class_maintenance,
1297            maintenance_print_raw_registers, _("\
1298 Print the internal register configuration including raw values.\n\
1299 Takes an optional file parameter."), &maintenanceprintlist);
1300   add_cmd ("cooked-registers", class_maintenance,
1301            maintenance_print_cooked_registers, _("\
1302 Print the internal register configuration including cooked values.\n\
1303 Takes an optional file parameter."), &maintenanceprintlist);
1304   add_cmd ("register-groups", class_maintenance,
1305            maintenance_print_register_groups, _("\
1306 Print the internal register configuration including each register's group.\n\
1307 Takes an optional file parameter."),
1308            &maintenanceprintlist);
1309
1310 }