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