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, 2008, 2009, 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "gdbarch.h"
  25 #include "gdbcmd.h"
  26 #include "regcache.h"
  27 #include "reggroups.h"
  28 #include "gdb_assert.h"
  29 #include "gdb_string.h"
  30 #include "gdbcmd.h"             /* For maintenanceprintlist.  */
  31 #include "observer.h"
  32 #include "exceptions.h"
  33
  34 /*
  35  * DATA STRUCTURE
  36  *
  37  * Here is the actual register cache.
  38  */
  39
  40 /* Per-architecture object describing the layout of a register cache.
  41    Computed once when the architecture is created.  */
  42
  43 struct gdbarch_data *regcache_descr_handle;
  44
  45 struct regcache_descr
  46 {
  47   /* The architecture this descriptor belongs to.  */
  48   struct gdbarch *gdbarch;
  49
  50   /* The raw register cache.  Each raw (or hard) register is supplied
  51      by the target interface.  The raw cache should not contain
  52      redundant information - if the PC is constructed from two
  53      registers then those registers and not the PC lives in the raw
  54      cache.  */
  55   int nr_raw_registers;
  56   long sizeof_raw_registers;
  57   long sizeof_raw_register_status;
  58
  59   /* The cooked register space.  Each cooked register in the range
  60      [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
  61      register.  The remaining [NR_RAW_REGISTERS
  62      .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
  63      both raw registers and memory by the architecture methods
  64      gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
  65   int nr_cooked_registers;
  66   long sizeof_cooked_registers;
  67   long sizeof_cooked_register_status;
  68
  69   /* Offset and size (in 8 bit bytes), of reach register in the
  70      register cache.  All registers (including those in the range
  71      [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
  72      offset.  */
  73   long *register_offset;
  74   long *sizeof_register;
  75
  76   /* Cached table containing the type of each register.  */
  77   struct type **register_type;
  78 };
  79
  80 static void *
  81 init_regcache_descr (struct gdbarch *gdbarch)
  82 {
  83   int i;
  84   struct regcache_descr *descr;
  85   gdb_assert (gdbarch != NULL);
  86
  87   /* Create an initial, zero filled, table.  */
  88   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  89   descr->gdbarch = gdbarch;
  90
  91   /* Total size of the register space.  The raw registers are mapped
  92      directly onto the raw register cache while the pseudo's are
  93      either mapped onto raw-registers or memory.  */
  94   descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
  95                                + gdbarch_num_pseudo_regs (gdbarch);
  96   descr->sizeof_cooked_register_status
  97     = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
  98
  99   /* Fill in a table of register types.  */
 100   descr->register_type
 101     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers,
 102                               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 = gdbarch_num_regs (gdbarch);
 109   descr->sizeof_raw_register_status = gdbarch_num_regs (gdbarch);
 110
 111   /* Lay out the register cache.
 112
 113      NOTE: cagney/2002-05-22: Only register_type() is used when
 114      constructing the register cache.  It is assumed that the
 115      register's raw size, virtual size and type length are all the
 116      same.  */
 117
 118   {
 119     long offset = 0;
 120
 121     descr->sizeof_register
 122       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 123     descr->register_offset
 124       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 125     for (i = 0; i < descr->nr_raw_registers; i++)
 126       {
 127         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 128         descr->register_offset[i] = offset;
 129         offset += descr->sizeof_register[i];
 130         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 131       }
 132     /* Set the real size of the raw register cache buffer.  */
 133     descr->sizeof_raw_registers = offset;
 134
 135     for (; i < descr->nr_cooked_registers; i++)
 136       {
 137         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 138         descr->register_offset[i] = offset;
 139         offset += descr->sizeof_register[i];
 140         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 141       }
 142     /* Set the real size of the readonly register cache buffer.  */
 143     descr->sizeof_cooked_registers = offset;
 144   }
 145
 146   return descr;
 147 }
 148
 149 static struct regcache_descr *
 150 regcache_descr (struct gdbarch *gdbarch)
 151 {
 152   return gdbarch_data (gdbarch, regcache_descr_handle);
 153 }
 154
 155 /* Utility functions returning useful register attributes stored in
 156    the regcache descr.  */
 157
 158 struct type *
 159 register_type (struct gdbarch *gdbarch, int regnum)
 160 {
 161   struct regcache_descr *descr = regcache_descr (gdbarch);
 162
 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
 176   gdb_assert (regnum >= 0
 177               && regnum < (gdbarch_num_regs (gdbarch)
 178                            + gdbarch_num_pseudo_regs (gdbarch)));
 179   size = descr->sizeof_register[regnum];
 180   return size;
 181 }
 182
 183 /* The register cache for storing raw register values.  */
 184
 185 struct regcache
 186 {
 187   struct regcache_descr *descr;
 188
 189   /* The address space of this register cache (for registers where it
 190      makes sense, like PC or SP).  */
 191   struct address_space *aspace;
 192
 193   /* The register buffers.  A read-only register cache can hold the
 194      full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
 195      register cache can only hold [0 .. gdbarch_num_regs).  */
 196   gdb_byte *registers;
 197   /* Register cache status.  */
 198   signed char *register_status;
 199   /* Is this a read-only cache?  A read-only cache is used for saving
 200      the target's register state (e.g, across an inferior function
 201      call or just before forcing a function return).  A read-only
 202      cache can only be updated via the methods regcache_dup() and
 203      regcache_cpy().  The actual contents are determined by the
 204      reggroup_save and reggroup_restore methods.  */
 205   int readonly_p;
 206   /* If this is a read-write cache, which thread's registers is
 207      it connected to?  */
 208   ptid_t ptid;
 209 };
 210
 211 static struct regcache *
 212 regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
 213                     int readonly_p)
 214 {
 215   struct regcache_descr *descr;
 216   struct regcache *regcache;
 217
 218   gdb_assert (gdbarch != NULL);
 219   descr = regcache_descr (gdbarch);
 220   regcache = XMALLOC (struct regcache);
 221   regcache->descr = descr;
 222   regcache->readonly_p = readonly_p;
 223   if (readonly_p)
 224     {
 225       regcache->registers
 226         = XCALLOC (descr->sizeof_cooked_registers, gdb_byte);
 227       regcache->register_status
 228         = XCALLOC (descr->sizeof_cooked_register_status, gdb_byte);
 229     }
 230   else
 231     {
 232       regcache->registers
 233         = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
 234       regcache->register_status
 235         = XCALLOC (descr->sizeof_raw_register_status, gdb_byte);
 236     }
 237   regcache->aspace = aspace;
 238   regcache->ptid = minus_one_ptid;
 239   return regcache;
 240 }
 241
 242 struct regcache *
 243 regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
 244 {
 245   return regcache_xmalloc_1 (gdbarch, aspace, 1);
 246 }
 247
 248 void
 249 regcache_xfree (struct regcache *regcache)
 250 {
 251   if (regcache == NULL)
 252     return;
 253   xfree (regcache->registers);
 254   xfree (regcache->register_status);
 255   xfree (regcache);
 256 }
 257
 258 static void
 259 do_regcache_xfree (void *data)
 260 {
 261   regcache_xfree (data);
 262 }
 263
 264 struct cleanup *
 265 make_cleanup_regcache_xfree (struct regcache *regcache)
 266 {
 267   return make_cleanup (do_regcache_xfree, regcache);
 268 }
 269
 270 /* Return REGCACHE's architecture.  */
 271
 272 struct gdbarch *
 273 get_regcache_arch (const struct regcache *regcache)
 274 {
 275   return regcache->descr->gdbarch;
 276 }
 277
 278 struct address_space *
 279 get_regcache_aspace (const struct regcache *regcache)
 280 {
 281   return regcache->aspace;
 282 }
 283
 284 /* Return  a pointer to register REGNUM's buffer cache.  */
 285
 286 static gdb_byte *
 287 register_buffer (const struct regcache *regcache, int regnum)
 288 {
 289   return regcache->registers + regcache->descr->register_offset[regnum];
 290 }
 291
 292 void
 293 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 294                void *src)
 295 {
 296   struct gdbarch *gdbarch = dst->descr->gdbarch;
 297   gdb_byte buf[MAX_REGISTER_SIZE];
 298   int regnum;
 299
 300   /* The DST should be `read-only', if it wasn't then the save would
 301      end up trying to write the register values back out to the
 302      target.  */
 303   gdb_assert (dst->readonly_p);
 304   /* Clear the dest.  */
 305   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 306   memset (dst->register_status, 0,
 307           dst->descr->sizeof_cooked_register_status);
 308   /* Copy over any registers (identified by their membership in the
 309      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
 310      gdbarch_num_pseudo_regs) range is checked since some architectures need
 311      to save/restore `cooked' registers that live in memory.  */
 312   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 313     {
 314       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 315         {
 316           enum register_status status = cooked_read (src, regnum, buf);
 317
 318           if (status == REG_VALID)
 319             memcpy (register_buffer (dst, regnum), buf,
 320                     register_size (gdbarch, regnum));
 321           else
 322             {
 323               gdb_assert (status != REG_UNKNOWN);
 324
 325               memset (register_buffer (dst, regnum), 0,
 326                       register_size (gdbarch, regnum));
 327             }
 328           dst->register_status[regnum] = status;
 329         }
 330     }
 331 }
 332
 333 void
 334 regcache_restore (struct regcache *dst,
 335                   regcache_cooked_read_ftype *cooked_read,
 336                   void *cooked_read_context)
 337 {
 338   struct gdbarch *gdbarch = dst->descr->gdbarch;
 339   gdb_byte buf[MAX_REGISTER_SIZE];
 340   int regnum;
 341
 342   /* The dst had better not be read-only.  If it is, the `restore'
 343      doesn't make much sense.  */
 344   gdb_assert (!dst->readonly_p);
 345   /* Copy over any registers, being careful to only restore those that
 346      were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
 347      + gdbarch_num_pseudo_regs) range is checked since some architectures need
 348      to save/restore `cooked' registers that live in memory.  */
 349   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 350     {
 351       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 352         {
 353           int valid = cooked_read (cooked_read_context, regnum, buf);
 354
 355           if (valid)
 356             regcache_cooked_write (dst, regnum, buf);
 357         }
 358     }
 359 }
 360
 361 static enum register_status
 362 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 363 {
 364   struct regcache *regcache = src;
 365
 366   return regcache_cooked_read (regcache, regnum, buf);
 367 }
 368
 369 void
 370 regcache_cpy (struct regcache *dst, struct regcache *src)
 371 {
 372   gdb_assert (src != NULL && dst != NULL);
 373   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 374   gdb_assert (src != dst);
 375   gdb_assert (src->readonly_p || dst->readonly_p);
 376
 377   if (!src->readonly_p)
 378     regcache_save (dst, do_cooked_read, src);
 379   else if (!dst->readonly_p)
 380     regcache_restore (dst, do_cooked_read, src);
 381   else
 382     regcache_cpy_no_passthrough (dst, src);
 383 }
 384
 385 void
 386 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 387 {
 388   gdb_assert (src != NULL && dst != NULL);
 389   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 390   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 391      move of data into a thread's regcache.  Doing this would be silly
 392      - it would mean that regcache->register_status would be
 393      completely invalid.  */
 394   gdb_assert (dst->readonly_p && src->readonly_p);
 395
 396   memcpy (dst->registers, src->registers,
 397           dst->descr->sizeof_cooked_registers);
 398   memcpy (dst->register_status, src->register_status,
 399           dst->descr->sizeof_cooked_register_status);
 400 }
 401
 402 struct regcache *
 403 regcache_dup (struct regcache *src)
 404 {
 405   struct regcache *newbuf;
 406
 407   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
 408   regcache_cpy (newbuf, src);
 409   return newbuf;
 410 }
 411
 412 int
 413 regcache_register_status (const struct regcache *regcache, int regnum)
 414 {
 415   gdb_assert (regcache != NULL);
 416   gdb_assert (regnum >= 0);
 417   if (regcache->readonly_p)
 418     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 419   else
 420     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 421
 422   return regcache->register_status[regnum];
 423 }
 424
 425 void
 426 regcache_invalidate (struct regcache *regcache, int regnum)
 427 {
 428   gdb_assert (regcache != NULL);
 429   gdb_assert (regnum >= 0);
 430   gdb_assert (!regcache->readonly_p);
 431   gdb_assert (regnum < regcache->descr->nr_raw_registers);
 432   regcache->register_status[regnum] = REG_UNKNOWN;
 433 }
 434
 435
 436 /* Global structure containing the current regcache.  */
 437
 438 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 439    recording if the register values have been changed (eg. by the
 440    user).  Therefore all registers must be written back to the
 441    target when appropriate.  */
 442
 443 struct regcache_list
 444 {
 445   struct regcache *regcache;
 446   struct regcache_list *next;
 447 };
 448
 449 static struct regcache_list *current_regcache;
 450
 451 struct regcache *
 452 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
 453 {
 454   struct regcache_list *list;
 455   struct regcache *new_regcache;
 456
 457   for (list = current_regcache; list; list = list->next)
 458     if (ptid_equal (list->regcache->ptid, ptid)
 459         && get_regcache_arch (list->regcache) == gdbarch)
 460       return list->regcache;
 461
 462   new_regcache = regcache_xmalloc_1 (gdbarch,
 463                                      target_thread_address_space (ptid), 0);
 464   new_regcache->ptid = ptid;
 465   gdb_assert (new_regcache->aspace != NULL);
 466
 467   list = xmalloc (sizeof (struct regcache_list));
 468   list->regcache = new_regcache;
 469   list->next = current_regcache;
 470   current_regcache = list;
 471
 472   return new_regcache;
 473 }
 474
 475 static ptid_t current_thread_ptid;
 476 static struct gdbarch *current_thread_arch;
 477
 478 struct regcache *
 479 get_thread_regcache (ptid_t ptid)
 480 {
 481   if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
 482     {
 483       current_thread_ptid = ptid;
 484       current_thread_arch = target_thread_architecture (ptid);
 485     }
 486
 487   return get_thread_arch_regcache (ptid, current_thread_arch);
 488 }
 489
 490 struct regcache *
 491 get_current_regcache (void)
 492 {
 493   return get_thread_regcache (inferior_ptid);
 494 }
 495
 496
 497 /* Observer for the target_changed event.  */
 498
 499 static void
 500 regcache_observer_target_changed (struct target_ops *target)
 501 {
 502   registers_changed ();
 503 }
 504
 505 /* Update global variables old ptids to hold NEW_PTID if they were
 506    holding OLD_PTID.  */
 507 static void
 508 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
 509 {
 510   struct regcache_list *list;
 511
 512   for (list = current_regcache; list; list = list->next)
 513     if (ptid_equal (list->regcache->ptid, old_ptid))
 514       list->regcache->ptid = new_ptid;
 515 }
 516
 517 /* Low level examining and depositing of registers.
 518
 519    The caller is responsible for making sure that the inferior is
 520    stopped before calling the fetching routines, or it will get
 521    garbage.  (a change from GDB version 3, in which the caller got the
 522    value from the last stop).  */
 523
 524 /* REGISTERS_CHANGED ()
 525
 526    Indicate that registers may have changed, so invalidate the cache.  */
 527
 528 void
 529 registers_changed_ptid (ptid_t ptid)
 530 {
 531   struct regcache_list *list, **list_link;
 532   int wildcard = ptid_equal (ptid, minus_one_ptid);
 533
 534   list = current_regcache;
 535   list_link = &current_regcache;
 536   while (list)
 537     {
 538       if (ptid_match (list->regcache->ptid, ptid))
 539         {
 540           struct regcache_list *dead = list;
 541
 542           *list_link = list->next;
 543           regcache_xfree (list->regcache);
 544           list = *list_link;
 545           xfree (dead);
 546           continue;
 547         }
 548
 549       list_link = &list->next;
 550       list = *list_link;
 551     }
 552
 553   if (wildcard || ptid_equal (ptid, current_thread_ptid))
 554     {
 555       current_thread_ptid = null_ptid;
 556       current_thread_arch = NULL;
 557     }
 558
 559   if (wildcard || ptid_equal (ptid, inferior_ptid))
 560     {
 561       /* We just deleted the regcache of the current thread.  Need to
 562          forget about any frames we have cached, too.  */
 563       reinit_frame_cache ();
 564     }
 565 }
 566
 567 void
 568 registers_changed (void)
 569 {
 570   registers_changed_ptid (minus_one_ptid);
 571
 572   /* Force cleanup of any alloca areas if using C alloca instead of
 573      a builtin alloca.  This particular call is used to clean up
 574      areas allocated by low level target code which may build up
 575      during lengthy interactions between gdb and the target before
 576      gdb gives control to the user (ie watchpoints).  */
 577   alloca (0);
 578 }
 579
 580 enum register_status
 581 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 582 {
 583   gdb_assert (regcache != NULL && buf != NULL);
 584   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 585   /* Make certain that the register cache is up-to-date with respect
 586      to the current thread.  This switching shouldn't be necessary
 587      only there is still only one target side register cache.  Sigh!
 588      On the bright side, at least there is a regcache object.  */
 589   if (!regcache->readonly_p)
 590     {
 591       if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
 592         {
 593           struct cleanup *old_chain = save_inferior_ptid ();
 594
 595           inferior_ptid = regcache->ptid;
 596           target_fetch_registers (regcache, regnum);
 597           do_cleanups (old_chain);
 598         }
 599 #if 0
 600       /* FIXME: cagney/2004-08-07: At present a number of targets
 601          forget (or didn't know that they needed) to set this leading to
 602          panics.  Also is the problem that targets need to indicate
 603          that a register is in one of the possible states: valid,
 604          undefined, unknown.  The last of which isn't yet
 605          possible.  */
 606       gdb_assert (regcache_register_status (regcache, regnum) == REG_VALID);
 607 #endif
 608     }
 609
 610   if (regcache->register_status[regnum] != REG_VALID)
 611     memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 612   else
 613     memcpy (buf, register_buffer (regcache, regnum),
 614             regcache->descr->sizeof_register[regnum]);
 615
 616   return regcache->register_status[regnum];
 617 }
 618
 619 enum register_status
 620 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 621 {
 622   gdb_byte *buf;
 623   enum register_status status;
 624
 625   gdb_assert (regcache != NULL);
 626   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 627   buf = alloca (regcache->descr->sizeof_register[regnum]);
 628   status = regcache_raw_read (regcache, regnum, buf);
 629   if (status == REG_VALID)
 630     *val = extract_signed_integer
 631       (buf, regcache->descr->sizeof_register[regnum],
 632        gdbarch_byte_order (regcache->descr->gdbarch));
 633   else
 634     *val = 0;
 635   return status;
 636 }
 637
 638 enum register_status
 639 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 640                             ULONGEST *val)
 641 {
 642   gdb_byte *buf;
 643   enum register_status status;
 644
 645   gdb_assert (regcache != NULL);
 646   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 647   buf = alloca (regcache->descr->sizeof_register[regnum]);
 648   status = regcache_raw_read (regcache, regnum, buf);
 649   if (status == REG_VALID)
 650     *val = extract_unsigned_integer
 651       (buf, regcache->descr->sizeof_register[regnum],
 652        gdbarch_byte_order (regcache->descr->gdbarch));
 653   else
 654     *val = 0;
 655   return status;
 656 }
 657
 658 void
 659 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 660 {
 661   void *buf;
 662
 663   gdb_assert (regcache != NULL);
 664   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 665   buf = alloca (regcache->descr->sizeof_register[regnum]);
 666   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 667                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 668   regcache_raw_write (regcache, regnum, buf);
 669 }
 670
 671 void
 672 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 673                              ULONGEST val)
 674 {
 675   void *buf;
 676
 677   gdb_assert (regcache != NULL);
 678   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 679   buf = alloca (regcache->descr->sizeof_register[regnum]);
 680   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 681                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 682   regcache_raw_write (regcache, regnum, buf);
 683 }
 684
 685 enum register_status
 686 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 687 {
 688   gdb_assert (regnum >= 0);
 689   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 690   if (regnum < regcache->descr->nr_raw_registers)
 691     return regcache_raw_read (regcache, regnum, buf);
 692   else if (regcache->readonly_p
 693            && regcache->register_status[regnum] != REG_UNKNOWN)
 694     {
 695       /* Read-only register cache, perhaps the cooked value was
 696          cached?  */
 697       struct gdbarch *gdbarch = regcache->descr->gdbarch;
 698
 699       if (regcache->register_status[regnum] == REG_VALID)
 700         memcpy (buf, register_buffer (regcache, regnum),
 701                 regcache->descr->sizeof_register[regnum]);
 702       else
 703         memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 704
 705       return regcache->register_status[regnum];
 706     }
 707   else
 708     return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 709                                          regnum, buf);
 710 }
 711
 712 enum register_status
 713 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 714                              LONGEST *val)
 715 {
 716   enum register_status status;
 717   gdb_byte *buf;
 718
 719   gdb_assert (regcache != NULL);
 720   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 721   buf = alloca (regcache->descr->sizeof_register[regnum]);
 722   status = regcache_cooked_read (regcache, regnum, buf);
 723   if (status == REG_VALID)
 724     *val = extract_signed_integer
 725       (buf, regcache->descr->sizeof_register[regnum],
 726        gdbarch_byte_order (regcache->descr->gdbarch));
 727   else
 728     *val = 0;
 729   return status;
 730 }
 731
 732 enum register_status
 733 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 734                                ULONGEST *val)
 735 {
 736   enum register_status status;
 737   gdb_byte *buf;
 738
 739   gdb_assert (regcache != NULL);
 740   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 741   buf = alloca (regcache->descr->sizeof_register[regnum]);
 742   status = regcache_cooked_read (regcache, regnum, buf);
 743   if (status == REG_VALID)
 744     *val = extract_unsigned_integer
 745       (buf, regcache->descr->sizeof_register[regnum],
 746        gdbarch_byte_order (regcache->descr->gdbarch));
 747   else
 748     *val = 0;
 749   return status;
 750 }
 751
 752 void
 753 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 754                               LONGEST val)
 755 {
 756   void *buf;
 757
 758   gdb_assert (regcache != NULL);
 759   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 760   buf = alloca (regcache->descr->sizeof_register[regnum]);
 761   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 762                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 763   regcache_cooked_write (regcache, regnum, buf);
 764 }
 765
 766 void
 767 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 768                                 ULONGEST val)
 769 {
 770   void *buf;
 771
 772   gdb_assert (regcache != NULL);
 773   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 774   buf = alloca (regcache->descr->sizeof_register[regnum]);
 775   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 776                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 777   regcache_cooked_write (regcache, regnum, buf);
 778 }
 779
 780 void
 781 regcache_raw_write (struct regcache *regcache, int regnum,
 782                     const gdb_byte *buf)
 783 {
 784   struct cleanup *old_chain;
 785
 786   gdb_assert (regcache != NULL && buf != NULL);
 787   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 788   gdb_assert (!regcache->readonly_p);
 789
 790   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 791      change the registers array if something writes to this register.  */
 792   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
 793     return;
 794
 795   /* If we have a valid copy of the register, and new value == old
 796      value, then don't bother doing the actual store.  */
 797   if (regcache_register_status (regcache, regnum) == REG_VALID
 798       && (memcmp (register_buffer (regcache, regnum), buf,
 799                   regcache->descr->sizeof_register[regnum]) == 0))
 800     return;
 801
 802   old_chain = save_inferior_ptid ();
 803   inferior_ptid = regcache->ptid;
 804
 805   target_prepare_to_store (regcache);
 806   memcpy (register_buffer (regcache, regnum), buf,
 807           regcache->descr->sizeof_register[regnum]);
 808   regcache->register_status[regnum] = REG_VALID;
 809   target_store_registers (regcache, regnum);
 810
 811   do_cleanups (old_chain);
 812 }
 813
 814 void
 815 regcache_cooked_write (struct regcache *regcache, int regnum,
 816                        const gdb_byte *buf)
 817 {
 818   gdb_assert (regnum >= 0);
 819   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 820   if (regnum < regcache->descr->nr_raw_registers)
 821     regcache_raw_write (regcache, regnum, buf);
 822   else
 823     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 824                                    regnum, buf);
 825 }
 826
 827 /* Perform a partial register transfer using a read, modify, write
 828    operation.  */
 829
 830 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 831                                     void *buf);
 832 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 833                                      const void *buf);
 834
 835 static enum register_status
 836 regcache_xfer_part (struct regcache *regcache, int regnum,
 837                     int offset, int len, void *in, const void *out,
 838                     enum register_status (*read) (struct regcache *regcache,
 839                                                   int regnum,
 840                                                   gdb_byte *buf),
 841                     void (*write) (struct regcache *regcache, int regnum,
 842                                    const gdb_byte *buf))
 843 {
 844   struct regcache_descr *descr = regcache->descr;
 845   gdb_byte reg[MAX_REGISTER_SIZE];
 846
 847   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 848   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 849   /* Something to do?  */
 850   if (offset + len == 0)
 851     return REG_VALID;
 852   /* Read (when needed) ...  */
 853   if (in != NULL
 854       || offset > 0
 855       || offset + len < descr->sizeof_register[regnum])
 856     {
 857       enum register_status status;
 858
 859       gdb_assert (read != NULL);
 860       status = read (regcache, regnum, reg);
 861       if (status != REG_VALID)
 862         return status;
 863     }
 864   /* ... modify ...  */
 865   if (in != NULL)
 866     memcpy (in, reg + offset, len);
 867   if (out != NULL)
 868     memcpy (reg + offset, out, len);
 869   /* ... write (when needed).  */
 870   if (out != NULL)
 871     {
 872       gdb_assert (write != NULL);
 873       write (regcache, regnum, reg);
 874     }
 875
 876   return REG_VALID;
 877 }
 878
 879 enum register_status
 880 regcache_raw_read_part (struct regcache *regcache, int regnum,
 881                         int offset, int len, gdb_byte *buf)
 882 {
 883   struct regcache_descr *descr = regcache->descr;
 884
 885   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 886   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 887                              regcache_raw_read, regcache_raw_write);
 888 }
 889
 890 void
 891 regcache_raw_write_part (struct regcache *regcache, int regnum,
 892                          int offset, int len, const gdb_byte *buf)
 893 {
 894   struct regcache_descr *descr = regcache->descr;
 895
 896   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 897   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 898                       regcache_raw_read, regcache_raw_write);
 899 }
 900
 901 enum register_status
 902 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 903                            int offset, int len, gdb_byte *buf)
 904 {
 905   struct regcache_descr *descr = regcache->descr;
 906
 907   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 908   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 909                              regcache_cooked_read, regcache_cooked_write);
 910 }
 911
 912 void
 913 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 914                             int offset, int len, const gdb_byte *buf)
 915 {
 916   struct regcache_descr *descr = regcache->descr;
 917
 918   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 919   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 920                       regcache_cooked_read, regcache_cooked_write);
 921 }
 922
 923 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 924
 925 void
 926 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 927 {
 928   void *regbuf;
 929   size_t size;
 930
 931   gdb_assert (regcache != NULL);
 932   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 933   gdb_assert (!regcache->readonly_p);
 934
 935   regbuf = register_buffer (regcache, regnum);
 936   size = regcache->descr->sizeof_register[regnum];
 937
 938   if (buf)
 939     {
 940       memcpy (regbuf, buf, size);
 941       regcache->register_status[regnum] = REG_VALID;
 942     }
 943   else
 944     {
 945       /* This memset not strictly necessary, but better than garbage
 946          in case the register value manages to escape somewhere (due
 947          to a bug, no less).  */
 948       memset (regbuf, 0, size);
 949       regcache->register_status[regnum] = REG_UNAVAILABLE;
 950     }
 951 }
 952
 953 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 954
 955 void
 956 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 957 {
 958   const void *regbuf;
 959   size_t size;
 960
 961   gdb_assert (regcache != NULL && buf != NULL);
 962   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 963
 964   regbuf = register_buffer (regcache, regnum);
 965   size = regcache->descr->sizeof_register[regnum];
 966   memcpy (buf, regbuf, size);
 967 }
 968
 969
 970 /* Special handling for register PC.  */
 971
 972 CORE_ADDR
 973 regcache_read_pc (struct regcache *regcache)
 974 {
 975   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 976
 977   CORE_ADDR pc_val;
 978
 979   if (gdbarch_read_pc_p (gdbarch))
 980     pc_val = gdbarch_read_pc (gdbarch, regcache);
 981   /* Else use per-frame method on get_current_frame.  */
 982   else if (gdbarch_pc_regnum (gdbarch) >= 0)
 983     {
 984       ULONGEST raw_val;
 985
 986       if (regcache_cooked_read_unsigned (regcache,
 987                                          gdbarch_pc_regnum (gdbarch),
 988                                          &raw_val) == REG_UNAVAILABLE)
 989         throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
 990
 991       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
 992     }
 993   else
 994     internal_error (__FILE__, __LINE__,
 995                     _("regcache_read_pc: Unable to find PC"));
 996   return pc_val;
 997 }
 998
 999 void
1000 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1001 {
1002   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1003
1004   if (gdbarch_write_pc_p (gdbarch))
1005     gdbarch_write_pc (gdbarch, regcache, pc);
1006   else if (gdbarch_pc_regnum (gdbarch) >= 0)
1007     regcache_cooked_write_unsigned (regcache,
1008                                     gdbarch_pc_regnum (gdbarch), pc);
1009   else
1010     internal_error (__FILE__, __LINE__,
1011                     _("regcache_write_pc: Unable to update PC"));
1012
1013   /* Writing the PC (for instance, from "load") invalidates the
1014      current frame.  */
1015   reinit_frame_cache ();
1016 }
1017
1018
1019 static void
1020 reg_flush_command (char *command, int from_tty)
1021 {
1022   /* Force-flush the register cache.  */
1023   registers_changed ();
1024   if (from_tty)
1025     printf_filtered (_("Register cache flushed.\n"));
1026 }
1027
1028 static void
1029 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1030                    const unsigned char *buf, long len)
1031 {
1032   int i;
1033
1034   switch (endian)
1035     {
1036     case BFD_ENDIAN_BIG:
1037       for (i = 0; i < len; i++)
1038         fprintf_unfiltered (file, "%02x", buf[i]);
1039       break;
1040     case BFD_ENDIAN_LITTLE:
1041       for (i = len - 1; i >= 0; i--)
1042         fprintf_unfiltered (file, "%02x", buf[i]);
1043       break;
1044     default:
1045       internal_error (__FILE__, __LINE__, _("Bad switch"));
1046     }
1047 }
1048
1049 enum regcache_dump_what
1050 {
1051   regcache_dump_none, regcache_dump_raw,
1052   regcache_dump_cooked, regcache_dump_groups
1053 };
1054
1055 static void
1056 regcache_dump (struct regcache *regcache, struct ui_file *file,
1057                enum regcache_dump_what what_to_dump)
1058 {
1059   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1060   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1061   int regnum;
1062   int footnote_nr = 0;
1063   int footnote_register_size = 0;
1064   int footnote_register_offset = 0;
1065   int footnote_register_type_name_null = 0;
1066   long register_offset = 0;
1067   unsigned char buf[MAX_REGISTER_SIZE];
1068
1069 #if 0
1070   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1071                       regcache->descr->nr_raw_registers);
1072   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1073                       regcache->descr->nr_cooked_registers);
1074   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1075                       regcache->descr->sizeof_raw_registers);
1076   fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
1077                       regcache->descr->sizeof_raw_register_status);
1078   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
1079                       gdbarch_num_regs (gdbarch));
1080   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
1081                       gdbarch_num_pseudo_regs (gdbarch));
1082 #endif
1083
1084   gdb_assert (regcache->descr->nr_cooked_registers
1085               == (gdbarch_num_regs (gdbarch)
1086                   + gdbarch_num_pseudo_regs (gdbarch)));
1087
1088   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1089     {
1090       /* Name.  */
1091       if (regnum < 0)
1092         fprintf_unfiltered (file, " %-10s", "Name");
1093       else
1094         {
1095           const char *p = gdbarch_register_name (gdbarch, regnum);
1096
1097           if (p == NULL)
1098             p = "";
1099           else if (p[0] == '\0')
1100             p = "''";
1101           fprintf_unfiltered (file, " %-10s", p);
1102         }
1103
1104       /* Number.  */
1105       if (regnum < 0)
1106         fprintf_unfiltered (file, " %4s", "Nr");
1107       else
1108         fprintf_unfiltered (file, " %4d", regnum);
1109
1110       /* Relative number.  */
1111       if (regnum < 0)
1112         fprintf_unfiltered (file, " %4s", "Rel");
1113       else if (regnum < gdbarch_num_regs (gdbarch))
1114         fprintf_unfiltered (file, " %4d", regnum);
1115       else
1116         fprintf_unfiltered (file, " %4d",
1117                             (regnum - gdbarch_num_regs (gdbarch)));
1118
1119       /* Offset.  */
1120       if (regnum < 0)
1121         fprintf_unfiltered (file, " %6s  ", "Offset");
1122       else
1123         {
1124           fprintf_unfiltered (file, " %6ld",
1125                               regcache->descr->register_offset[regnum]);
1126           if (register_offset != regcache->descr->register_offset[regnum]
1127               || (regnum > 0
1128                   && (regcache->descr->register_offset[regnum]
1129                       != (regcache->descr->register_offset[regnum - 1]
1130                           + regcache->descr->sizeof_register[regnum - 1])))
1131               )
1132             {
1133               if (!footnote_register_offset)
1134                 footnote_register_offset = ++footnote_nr;
1135               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1136             }
1137           else
1138             fprintf_unfiltered (file, "  ");
1139           register_offset = (regcache->descr->register_offset[regnum]
1140                              + regcache->descr->sizeof_register[regnum]);
1141         }
1142
1143       /* Size.  */
1144       if (regnum < 0)
1145         fprintf_unfiltered (file, " %5s ", "Size");
1146       else
1147         fprintf_unfiltered (file, " %5ld",
1148                             regcache->descr->sizeof_register[regnum]);
1149
1150       /* Type.  */
1151       {
1152         const char *t;
1153
1154         if (regnum < 0)
1155           t = "Type";
1156         else
1157           {
1158             static const char blt[] = "builtin_type";
1159
1160             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1161             if (t == NULL)
1162               {
1163                 char *n;
1164
1165                 if (!footnote_register_type_name_null)
1166                   footnote_register_type_name_null = ++footnote_nr;
1167                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1168                 make_cleanup (xfree, n);
1169                 t = n;
1170               }
1171             /* Chop a leading builtin_type.  */
1172             if (strncmp (t, blt, strlen (blt)) == 0)
1173               t += strlen (blt);
1174           }
1175         fprintf_unfiltered (file, " %-15s", t);
1176       }
1177
1178       /* Leading space always present.  */
1179       fprintf_unfiltered (file, " ");
1180
1181       /* Value, raw.  */
1182       if (what_to_dump == regcache_dump_raw)
1183         {
1184           if (regnum < 0)
1185             fprintf_unfiltered (file, "Raw value");
1186           else if (regnum >= regcache->descr->nr_raw_registers)
1187             fprintf_unfiltered (file, "<cooked>");
1188           else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
1189             fprintf_unfiltered (file, "<invalid>");
1190           else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
1191             fprintf_unfiltered (file, "<unavailable>");
1192           else
1193             {
1194               regcache_raw_read (regcache, regnum, buf);
1195               fprintf_unfiltered (file, "0x");
1196               dump_endian_bytes (file,
1197                                  gdbarch_byte_order (gdbarch), buf,
1198                                  regcache->descr->sizeof_register[regnum]);
1199             }
1200         }
1201
1202       /* Value, cooked.  */
1203       if (what_to_dump == regcache_dump_cooked)
1204         {
1205           if (regnum < 0)
1206             fprintf_unfiltered (file, "Cooked value");
1207           else
1208             {
1209               enum register_status status;
1210
1211               status = regcache_cooked_read (regcache, regnum, buf);
1212               if (status == REG_UNKNOWN)
1213                 fprintf_unfiltered (file, "<invalid>");
1214               else if (status == REG_UNAVAILABLE)
1215                 fprintf_unfiltered (file, "<unavailable>");
1216               else
1217                 {
1218                   fprintf_unfiltered (file, "0x");
1219                   dump_endian_bytes (file,
1220                                      gdbarch_byte_order (gdbarch), buf,
1221                                      regcache->descr->sizeof_register[regnum]);
1222                 }
1223             }
1224         }
1225
1226       /* Group members.  */
1227       if (what_to_dump == regcache_dump_groups)
1228         {
1229           if (regnum < 0)
1230             fprintf_unfiltered (file, "Groups");
1231           else
1232             {
1233               const char *sep = "";
1234               struct reggroup *group;
1235
1236               for (group = reggroup_next (gdbarch, NULL);
1237                    group != NULL;
1238                    group = reggroup_next (gdbarch, group))
1239                 {
1240                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1241                     {
1242                       fprintf_unfiltered (file,
1243                                           "%s%s", sep, reggroup_name (group));
1244                       sep = ",";
1245                     }
1246                 }
1247             }
1248         }
1249
1250       fprintf_unfiltered (file, "\n");
1251     }
1252
1253   if (footnote_register_size)
1254     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1255                         footnote_register_size);
1256   if (footnote_register_offset)
1257     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1258                         footnote_register_offset);
1259   if (footnote_register_type_name_null)
1260     fprintf_unfiltered (file,
1261                         "*%d: Register type's name NULL.\n",
1262                         footnote_register_type_name_null);
1263   do_cleanups (cleanups);
1264 }
1265
1266 static void
1267 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1268 {
1269   if (args == NULL)
1270     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1271   else
1272     {
1273       struct cleanup *cleanups;
1274       struct ui_file *file = gdb_fopen (args, "w");
1275
1276       if (file == NULL)
1277         perror_with_name (_("maintenance print architecture"));
1278       cleanups = make_cleanup_ui_file_delete (file);
1279       regcache_dump (get_current_regcache (), file, what_to_dump);
1280       do_cleanups (cleanups);
1281     }
1282 }
1283
1284 static void
1285 maintenance_print_registers (char *args, int from_tty)
1286 {
1287   regcache_print (args, regcache_dump_none);
1288 }
1289
1290 static void
1291 maintenance_print_raw_registers (char *args, int from_tty)
1292 {
1293   regcache_print (args, regcache_dump_raw);
1294 }
1295
1296 static void
1297 maintenance_print_cooked_registers (char *args, int from_tty)
1298 {
1299   regcache_print (args, regcache_dump_cooked);
1300 }
1301
1302 static void
1303 maintenance_print_register_groups (char *args, int from_tty)
1304 {
1305   regcache_print (args, regcache_dump_groups);
1306 }
1307
1308 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1309
1310 void
1311 _initialize_regcache (void)
1312 {
1313   regcache_descr_handle
1314     = gdbarch_data_register_post_init (init_regcache_descr);
1315
1316   observer_attach_target_changed (regcache_observer_target_changed);
1317   observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1318
1319   add_com ("flushregs", class_maintenance, reg_flush_command,
1320            _("Force gdb to flush its register cache (maintainer command)"));
1321
1322   add_cmd ("registers", class_maintenance, maintenance_print_registers,
1323            _("Print the internal register configuration.\n"
1324              "Takes an optional file parameter."), &maintenanceprintlist);
1325   add_cmd ("raw-registers", class_maintenance,
1326            maintenance_print_raw_registers,
1327            _("Print the internal register configuration "
1328              "including raw values.\n"
1329              "Takes an optional file parameter."), &maintenanceprintlist);
1330   add_cmd ("cooked-registers", class_maintenance,
1331            maintenance_print_cooked_registers,
1332            _("Print the internal register configuration "
1333              "including cooked values.\n"
1334              "Takes an optional file parameter."), &maintenanceprintlist);
1335   add_cmd ("register-groups", class_maintenance,
1336            maintenance_print_register_groups,
1337            _("Print the internal register configuration "
1338              "including each register's group.\n"
1339              "Takes an optional file parameter."),
1340            &maintenanceprintlist);
1341
1342 }