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