contrib/gdb-7/gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2013 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "target.h"
  23 #include "gdbarch.h"
  24 #include "gdbcmd.h"
  25 #include "regcache.h"
  26 #include "reggroups.h"
  27 #include "gdb_assert.h"
  28 #include "gdb_string.h"
  29 #include "gdbcmd.h"             /* For maintenanceprintlist.  */
  30 #include "observer.h"
  31 #include "exceptions.h"
  32 #include "remote.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 each 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, signed char);
 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, signed char);
 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 static 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           enum register_status status;
 354
 355           status = cooked_read (cooked_read_context, regnum, buf);
 356           if (status == REG_VALID)
 357             regcache_cooked_write (dst, regnum, buf);
 358         }
 359     }
 360 }
 361
 362 static enum register_status
 363 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 364 {
 365   struct regcache *regcache = src;
 366
 367   return regcache_cooked_read (regcache, regnum, buf);
 368 }
 369
 370 void
 371 regcache_cpy (struct regcache *dst, struct regcache *src)
 372 {
 373   gdb_assert (src != NULL && dst != NULL);
 374   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 375   gdb_assert (src != dst);
 376   gdb_assert (src->readonly_p || dst->readonly_p);
 377
 378   if (!src->readonly_p)
 379     regcache_save (dst, do_cooked_read, src);
 380   else if (!dst->readonly_p)
 381     regcache_restore (dst, do_cooked_read, src);
 382   else
 383     regcache_cpy_no_passthrough (dst, src);
 384 }
 385
 386 void
 387 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 388 {
 389   gdb_assert (src != NULL && dst != NULL);
 390   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 391   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 392      move of data into a thread's regcache.  Doing this would be silly
 393      - it would mean that regcache->register_status would be
 394      completely invalid.  */
 395   gdb_assert (dst->readonly_p && src->readonly_p);
 396
 397   memcpy (dst->registers, src->registers,
 398           dst->descr->sizeof_cooked_registers);
 399   memcpy (dst->register_status, src->register_status,
 400           dst->descr->sizeof_cooked_register_status);
 401 }
 402
 403 struct regcache *
 404 regcache_dup (struct regcache *src)
 405 {
 406   struct regcache *newbuf;
 407
 408   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
 409   regcache_cpy (newbuf, src);
 410   return newbuf;
 411 }
 412
 413 enum register_status
 414 regcache_register_status (const struct regcache *regcache, int regnum)
 415 {
 416   gdb_assert (regcache != NULL);
 417   gdb_assert (regnum >= 0);
 418   if (regcache->readonly_p)
 419     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 420   else
 421     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 422
 423   return regcache->register_status[regnum];
 424 }
 425
 426 void
 427 regcache_invalidate (struct regcache *regcache, int regnum)
 428 {
 429   gdb_assert (regcache != NULL);
 430   gdb_assert (regnum >= 0);
 431   gdb_assert (!regcache->readonly_p);
 432   gdb_assert (regnum < regcache->descr->nr_raw_registers);
 433   regcache->register_status[regnum] = REG_UNKNOWN;
 434 }
 435
 436
 437 /* Global structure containing the current regcache.  */
 438
 439 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 440    recording if the register values have been changed (eg. by the
 441    user).  Therefore all registers must be written back to the
 442    target when appropriate.  */
 443
 444 struct regcache_list
 445 {
 446   struct regcache *regcache;
 447   struct regcache_list *next;
 448 };
 449
 450 static struct regcache_list *current_regcache;
 451
 452 struct regcache *
 453 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
 454                                  struct address_space *aspace)
 455 {
 456   struct regcache_list *list;
 457   struct regcache *new_regcache;
 458
 459   for (list = current_regcache; list; list = list->next)
 460     if (ptid_equal (list->regcache->ptid, ptid)
 461         && get_regcache_arch (list->regcache) == gdbarch)
 462       return list->regcache;
 463
 464   new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
 465   new_regcache->ptid = ptid;
 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 struct regcache *
 476 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
 477 {
 478   struct address_space *aspace;
 479
 480   /* For the benefit of "maint print registers" & co when debugging an
 481      executable, allow dumping the regcache even when there is no
 482      thread selected (target_thread_address_space internal-errors if
 483      no address space is found).  Note that normal user commands will
 484      fail higher up on the call stack due to no
 485      target_has_registers.  */
 486   aspace = (ptid_equal (null_ptid, ptid)
 487             ? NULL
 488             : target_thread_address_space (ptid));
 489
 490   return get_thread_arch_aspace_regcache  (ptid, gdbarch, aspace);
 491 }
 492
 493 static ptid_t current_thread_ptid;
 494 static struct gdbarch *current_thread_arch;
 495
 496 struct regcache *
 497 get_thread_regcache (ptid_t ptid)
 498 {
 499   if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
 500     {
 501       current_thread_ptid = ptid;
 502       current_thread_arch = target_thread_architecture (ptid);
 503     }
 504
 505   return get_thread_arch_regcache (ptid, current_thread_arch);
 506 }
 507
 508 struct regcache *
 509 get_current_regcache (void)
 510 {
 511   return get_thread_regcache (inferior_ptid);
 512 }
 513
 514
 515 /* Observer for the target_changed event.  */
 516
 517 static void
 518 regcache_observer_target_changed (struct target_ops *target)
 519 {
 520   registers_changed ();
 521 }
 522
 523 /* Update global variables old ptids to hold NEW_PTID if they were
 524    holding OLD_PTID.  */
 525 static void
 526 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
 527 {
 528   struct regcache_list *list;
 529
 530   for (list = current_regcache; list; list = list->next)
 531     if (ptid_equal (list->regcache->ptid, old_ptid))
 532       list->regcache->ptid = new_ptid;
 533 }
 534
 535 /* Low level examining and depositing of registers.
 536
 537    The caller is responsible for making sure that the inferior is
 538    stopped before calling the fetching routines, or it will get
 539    garbage.  (a change from GDB version 3, in which the caller got the
 540    value from the last stop).  */
 541
 542 /* REGISTERS_CHANGED ()
 543
 544    Indicate that registers may have changed, so invalidate the cache.  */
 545
 546 void
 547 registers_changed_ptid (ptid_t ptid)
 548 {
 549   struct regcache_list *list, **list_link;
 550
 551   list = current_regcache;
 552   list_link = &current_regcache;
 553   while (list)
 554     {
 555       if (ptid_match (list->regcache->ptid, ptid))
 556         {
 557           struct regcache_list *dead = list;
 558
 559           *list_link = list->next;
 560           regcache_xfree (list->regcache);
 561           list = *list_link;
 562           xfree (dead);
 563           continue;
 564         }
 565
 566       list_link = &list->next;
 567       list = *list_link;
 568     }
 569
 570   if (ptid_match (current_thread_ptid, ptid))
 571     {
 572       current_thread_ptid = null_ptid;
 573       current_thread_arch = NULL;
 574     }
 575
 576   if (ptid_match (inferior_ptid, ptid))
 577     {
 578       /* We just deleted the regcache of the current thread.  Need to
 579          forget about any frames we have cached, too.  */
 580       reinit_frame_cache ();
 581     }
 582 }
 583
 584 void
 585 registers_changed (void)
 586 {
 587   registers_changed_ptid (minus_one_ptid);
 588
 589   /* Force cleanup of any alloca areas if using C alloca instead of
 590      a builtin alloca.  This particular call is used to clean up
 591      areas allocated by low level target code which may build up
 592      during lengthy interactions between gdb and the target before
 593      gdb gives control to the user (ie watchpoints).  */
 594   alloca (0);
 595 }
 596
 597 enum register_status
 598 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 599 {
 600   gdb_assert (regcache != NULL && buf != NULL);
 601   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 602   /* Make certain that the register cache is up-to-date with respect
 603      to the current thread.  This switching shouldn't be necessary
 604      only there is still only one target side register cache.  Sigh!
 605      On the bright side, at least there is a regcache object.  */
 606   if (!regcache->readonly_p
 607       && regcache_register_status (regcache, regnum) == REG_UNKNOWN)
 608     {
 609       struct cleanup *old_chain = save_inferior_ptid ();
 610
 611       inferior_ptid = regcache->ptid;
 612       target_fetch_registers (regcache, regnum);
 613       do_cleanups (old_chain);
 614
 615       /* A number of targets can't access the whole set of raw
 616          registers (because the debug API provides no means to get at
 617          them).  */
 618       if (regcache->register_status[regnum] == REG_UNKNOWN)
 619         regcache->register_status[regnum] = REG_UNAVAILABLE;
 620     }
 621
 622   if (regcache->register_status[regnum] != REG_VALID)
 623     memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 624   else
 625     memcpy (buf, register_buffer (regcache, regnum),
 626             regcache->descr->sizeof_register[regnum]);
 627
 628   return regcache->register_status[regnum];
 629 }
 630
 631 enum register_status
 632 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 633 {
 634   gdb_byte *buf;
 635   enum register_status status;
 636
 637   gdb_assert (regcache != NULL);
 638   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 639   buf = alloca (regcache->descr->sizeof_register[regnum]);
 640   status = regcache_raw_read (regcache, regnum, buf);
 641   if (status == REG_VALID)
 642     *val = extract_signed_integer
 643       (buf, regcache->descr->sizeof_register[regnum],
 644        gdbarch_byte_order (regcache->descr->gdbarch));
 645   else
 646     *val = 0;
 647   return status;
 648 }
 649
 650 enum register_status
 651 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 652                             ULONGEST *val)
 653 {
 654   gdb_byte *buf;
 655   enum register_status status;
 656
 657   gdb_assert (regcache != NULL);
 658   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 659   buf = alloca (regcache->descr->sizeof_register[regnum]);
 660   status = regcache_raw_read (regcache, regnum, buf);
 661   if (status == REG_VALID)
 662     *val = extract_unsigned_integer
 663       (buf, regcache->descr->sizeof_register[regnum],
 664        gdbarch_byte_order (regcache->descr->gdbarch));
 665   else
 666     *val = 0;
 667   return status;
 668 }
 669
 670 void
 671 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 672 {
 673   void *buf;
 674
 675   gdb_assert (regcache != NULL);
 676   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 677   buf = alloca (regcache->descr->sizeof_register[regnum]);
 678   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 679                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 680   regcache_raw_write (regcache, regnum, buf);
 681 }
 682
 683 void
 684 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 685                              ULONGEST val)
 686 {
 687   void *buf;
 688
 689   gdb_assert (regcache != NULL);
 690   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 691   buf = alloca (regcache->descr->sizeof_register[regnum]);
 692   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 693                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 694   regcache_raw_write (regcache, regnum, buf);
 695 }
 696
 697 enum register_status
 698 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 699 {
 700   gdb_assert (regnum >= 0);
 701   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 702   if (regnum < regcache->descr->nr_raw_registers)
 703     return regcache_raw_read (regcache, regnum, buf);
 704   else if (regcache->readonly_p
 705            && regcache->register_status[regnum] != REG_UNKNOWN)
 706     {
 707       /* Read-only register cache, perhaps the cooked value was
 708          cached?  */
 709       if (regcache->register_status[regnum] == REG_VALID)
 710         memcpy (buf, register_buffer (regcache, regnum),
 711                 regcache->descr->sizeof_register[regnum]);
 712       else
 713         memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 714
 715       return regcache->register_status[regnum];
 716     }
 717   else if (gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
 718     {
 719       struct value *mark, *computed;
 720       enum register_status result = REG_VALID;
 721
 722       mark = value_mark ();
 723
 724       computed = gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
 725                                                      regcache, regnum);
 726       if (value_entirely_available (computed))
 727         memcpy (buf, value_contents_raw (computed),
 728                 regcache->descr->sizeof_register[regnum]);
 729       else
 730         {
 731           memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 732           result = REG_UNAVAILABLE;
 733         }
 734
 735       value_free_to_mark (mark);
 736
 737       return result;
 738     }
 739   else
 740     return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 741                                          regnum, buf);
 742 }
 743
 744 struct value *
 745 regcache_cooked_read_value (struct regcache *regcache, int regnum)
 746 {
 747   gdb_assert (regnum >= 0);
 748   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 749
 750   if (regnum < regcache->descr->nr_raw_registers
 751       || (regcache->readonly_p
 752           && regcache->register_status[regnum] != REG_UNKNOWN)
 753       || !gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
 754     {
 755       struct value *result;
 756
 757       result = allocate_value (register_type (regcache->descr->gdbarch,
 758                                               regnum));
 759       VALUE_LVAL (result) = lval_register;
 760       VALUE_REGNUM (result) = regnum;
 761
 762       /* It is more efficient in general to do this delegation in this
 763          direction than in the other one, even though the value-based
 764          API is preferred.  */
 765       if (regcache_cooked_read (regcache, regnum,
 766                                 value_contents_raw (result)) == REG_UNAVAILABLE)
 767         mark_value_bytes_unavailable (result, 0,
 768                                       TYPE_LENGTH (value_type (result)));
 769
 770       return result;
 771     }
 772   else
 773     return gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
 774                                                regcache, regnum);
 775 }
 776
 777 enum register_status
 778 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 779                              LONGEST *val)
 780 {
 781   enum register_status status;
 782   gdb_byte *buf;
 783
 784   gdb_assert (regcache != NULL);
 785   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 786   buf = alloca (regcache->descr->sizeof_register[regnum]);
 787   status = regcache_cooked_read (regcache, regnum, buf);
 788   if (status == REG_VALID)
 789     *val = extract_signed_integer
 790       (buf, regcache->descr->sizeof_register[regnum],
 791        gdbarch_byte_order (regcache->descr->gdbarch));
 792   else
 793     *val = 0;
 794   return status;
 795 }
 796
 797 enum register_status
 798 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 799                                ULONGEST *val)
 800 {
 801   enum register_status status;
 802   gdb_byte *buf;
 803
 804   gdb_assert (regcache != NULL);
 805   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 806   buf = alloca (regcache->descr->sizeof_register[regnum]);
 807   status = regcache_cooked_read (regcache, regnum, buf);
 808   if (status == REG_VALID)
 809     *val = extract_unsigned_integer
 810       (buf, regcache->descr->sizeof_register[regnum],
 811        gdbarch_byte_order (regcache->descr->gdbarch));
 812   else
 813     *val = 0;
 814   return status;
 815 }
 816
 817 void
 818 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 819                               LONGEST val)
 820 {
 821   void *buf;
 822
 823   gdb_assert (regcache != NULL);
 824   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 825   buf = alloca (regcache->descr->sizeof_register[regnum]);
 826   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 827                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 828   regcache_cooked_write (regcache, regnum, buf);
 829 }
 830
 831 void
 832 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 833                                 ULONGEST val)
 834 {
 835   void *buf;
 836
 837   gdb_assert (regcache != NULL);
 838   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 839   buf = alloca (regcache->descr->sizeof_register[regnum]);
 840   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 841                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 842   regcache_cooked_write (regcache, regnum, buf);
 843 }
 844
 845 void
 846 regcache_raw_write (struct regcache *regcache, int regnum,
 847                     const gdb_byte *buf)
 848 {
 849   struct cleanup *old_chain;
 850
 851   gdb_assert (regcache != NULL && buf != NULL);
 852   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 853   gdb_assert (!regcache->readonly_p);
 854
 855   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 856      change the registers array if something writes to this register.  */
 857   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
 858     return;
 859
 860   /* If we have a valid copy of the register, and new value == old
 861      value, then don't bother doing the actual store.  */
 862   if (regcache_register_status (regcache, regnum) == REG_VALID
 863       && (memcmp (register_buffer (regcache, regnum), buf,
 864                   regcache->descr->sizeof_register[regnum]) == 0))
 865     return;
 866
 867   old_chain = save_inferior_ptid ();
 868   inferior_ptid = regcache->ptid;
 869
 870   target_prepare_to_store (regcache);
 871   memcpy (register_buffer (regcache, regnum), buf,
 872           regcache->descr->sizeof_register[regnum]);
 873   regcache->register_status[regnum] = REG_VALID;
 874   target_store_registers (regcache, regnum);
 875
 876   do_cleanups (old_chain);
 877 }
 878
 879 void
 880 regcache_cooked_write (struct regcache *regcache, int regnum,
 881                        const gdb_byte *buf)
 882 {
 883   gdb_assert (regnum >= 0);
 884   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 885   if (regnum < regcache->descr->nr_raw_registers)
 886     regcache_raw_write (regcache, regnum, buf);
 887   else
 888     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 889                                    regnum, buf);
 890 }
 891
 892 /* Perform a partial register transfer using a read, modify, write
 893    operation.  */
 894
 895 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 896                                     void *buf);
 897 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 898                                      const void *buf);
 899
 900 static enum register_status
 901 regcache_xfer_part (struct regcache *regcache, int regnum,
 902                     int offset, int len, void *in, const void *out,
 903                     enum register_status (*read) (struct regcache *regcache,
 904                                                   int regnum,
 905                                                   gdb_byte *buf),
 906                     void (*write) (struct regcache *regcache, int regnum,
 907                                    const gdb_byte *buf))
 908 {
 909   struct regcache_descr *descr = regcache->descr;
 910   gdb_byte reg[MAX_REGISTER_SIZE];
 911
 912   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 913   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 914   /* Something to do?  */
 915   if (offset + len == 0)
 916     return REG_VALID;
 917   /* Read (when needed) ...  */
 918   if (in != NULL
 919       || offset > 0
 920       || offset + len < descr->sizeof_register[regnum])
 921     {
 922       enum register_status status;
 923
 924       gdb_assert (read != NULL);
 925       status = read (regcache, regnum, reg);
 926       if (status != REG_VALID)
 927         return status;
 928     }
 929   /* ... modify ...  */
 930   if (in != NULL)
 931     memcpy (in, reg + offset, len);
 932   if (out != NULL)
 933     memcpy (reg + offset, out, len);
 934   /* ... write (when needed).  */
 935   if (out != NULL)
 936     {
 937       gdb_assert (write != NULL);
 938       write (regcache, regnum, reg);
 939     }
 940
 941   return REG_VALID;
 942 }
 943
 944 enum register_status
 945 regcache_raw_read_part (struct regcache *regcache, int regnum,
 946                         int offset, int len, gdb_byte *buf)
 947 {
 948   struct regcache_descr *descr = regcache->descr;
 949
 950   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 951   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 952                              regcache_raw_read, regcache_raw_write);
 953 }
 954
 955 void
 956 regcache_raw_write_part (struct regcache *regcache, int regnum,
 957                          int offset, int len, const gdb_byte *buf)
 958 {
 959   struct regcache_descr *descr = regcache->descr;
 960
 961   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 962   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 963                       regcache_raw_read, regcache_raw_write);
 964 }
 965
 966 enum register_status
 967 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 968                            int offset, int len, gdb_byte *buf)
 969 {
 970   struct regcache_descr *descr = regcache->descr;
 971
 972   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 973   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 974                              regcache_cooked_read, regcache_cooked_write);
 975 }
 976
 977 void
 978 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 979                             int offset, int len, const gdb_byte *buf)
 980 {
 981   struct regcache_descr *descr = regcache->descr;
 982
 983   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 984   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 985                       regcache_cooked_read, regcache_cooked_write);
 986 }
 987
 988 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 989
 990 void
 991 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 992 {
 993   void *regbuf;
 994   size_t size;
 995
 996   gdb_assert (regcache != NULL);
 997   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 998   gdb_assert (!regcache->readonly_p);
 999
1000   regbuf = register_buffer (regcache, regnum);
1001   size = regcache->descr->sizeof_register[regnum];
1002
1003   if (buf)
1004     {
1005       memcpy (regbuf, buf, size);
1006       regcache->register_status[regnum] = REG_VALID;
1007     }
1008   else
1009     {
1010       /* This memset not strictly necessary, but better than garbage
1011          in case the register value manages to escape somewhere (due
1012          to a bug, no less).  */
1013       memset (regbuf, 0, size);
1014       regcache->register_status[regnum] = REG_UNAVAILABLE;
1015     }
1016 }
1017
1018 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
1019
1020 void
1021 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1022 {
1023   const void *regbuf;
1024   size_t size;
1025
1026   gdb_assert (regcache != NULL && buf != NULL);
1027   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1028
1029   regbuf = register_buffer (regcache, regnum);
1030   size = regcache->descr->sizeof_register[regnum];
1031   memcpy (buf, regbuf, size);
1032 }
1033
1034
1035 /* Special handling for register PC.  */
1036
1037 CORE_ADDR
1038 regcache_read_pc (struct regcache *regcache)
1039 {
1040   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1041
1042   CORE_ADDR pc_val;
1043
1044   if (gdbarch_read_pc_p (gdbarch))
1045     pc_val = gdbarch_read_pc (gdbarch, regcache);
1046   /* Else use per-frame method on get_current_frame.  */
1047   else if (gdbarch_pc_regnum (gdbarch) >= 0)
1048     {
1049       ULONGEST raw_val;
1050
1051       if (regcache_cooked_read_unsigned (regcache,
1052                                          gdbarch_pc_regnum (gdbarch),
1053                                          &raw_val) == REG_UNAVAILABLE)
1054         throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1055
1056       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1057     }
1058   else
1059     internal_error (__FILE__, __LINE__,
1060                     _("regcache_read_pc: Unable to find PC"));
1061   return pc_val;
1062 }
1063
1064 void
1065 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1066 {
1067   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1068
1069   if (gdbarch_write_pc_p (gdbarch))
1070     gdbarch_write_pc (gdbarch, regcache, pc);
1071   else if (gdbarch_pc_regnum (gdbarch) >= 0)
1072     regcache_cooked_write_unsigned (regcache,
1073                                     gdbarch_pc_regnum (gdbarch), pc);
1074   else
1075     internal_error (__FILE__, __LINE__,
1076                     _("regcache_write_pc: Unable to update PC"));
1077
1078   /* Writing the PC (for instance, from "load") invalidates the
1079      current frame.  */
1080   reinit_frame_cache ();
1081 }
1082
1083
1084 static void
1085 reg_flush_command (char *command, int from_tty)
1086 {
1087   /* Force-flush the register cache.  */
1088   registers_changed ();
1089   if (from_tty)
1090     printf_filtered (_("Register cache flushed.\n"));
1091 }
1092
1093 static void
1094 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1095                    const gdb_byte *buf, long len)
1096 {
1097   int i;
1098
1099   switch (endian)
1100     {
1101     case BFD_ENDIAN_BIG:
1102       for (i = 0; i < len; i++)
1103         fprintf_unfiltered (file, "%02x", buf[i]);
1104       break;
1105     case BFD_ENDIAN_LITTLE:
1106       for (i = len - 1; i >= 0; i--)
1107         fprintf_unfiltered (file, "%02x", buf[i]);
1108       break;
1109     default:
1110       internal_error (__FILE__, __LINE__, _("Bad switch"));
1111     }
1112 }
1113
1114 enum regcache_dump_what
1115 {
1116   regcache_dump_none, regcache_dump_raw,
1117   regcache_dump_cooked, regcache_dump_groups,
1118   regcache_dump_remote
1119 };
1120
1121 static void
1122 regcache_dump (struct regcache *regcache, struct ui_file *file,
1123                enum regcache_dump_what what_to_dump)
1124 {
1125   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1126   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1127   int regnum;
1128   int footnote_nr = 0;
1129   int footnote_register_size = 0;
1130   int footnote_register_offset = 0;
1131   int footnote_register_type_name_null = 0;
1132   long register_offset = 0;
1133   gdb_byte buf[MAX_REGISTER_SIZE];
1134
1135 #if 0
1136   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1137                       regcache->descr->nr_raw_registers);
1138   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1139                       regcache->descr->nr_cooked_registers);
1140   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1141                       regcache->descr->sizeof_raw_registers);
1142   fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
1143                       regcache->descr->sizeof_raw_register_status);
1144   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
1145                       gdbarch_num_regs (gdbarch));
1146   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
1147                       gdbarch_num_pseudo_regs (gdbarch));
1148 #endif
1149
1150   gdb_assert (regcache->descr->nr_cooked_registers
1151               == (gdbarch_num_regs (gdbarch)
1152                   + gdbarch_num_pseudo_regs (gdbarch)));
1153
1154   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1155     {
1156       /* Name.  */
1157       if (regnum < 0)
1158         fprintf_unfiltered (file, " %-10s", "Name");
1159       else
1160         {
1161           const char *p = gdbarch_register_name (gdbarch, regnum);
1162
1163           if (p == NULL)
1164             p = "";
1165           else if (p[0] == '\0')
1166             p = "''";
1167           fprintf_unfiltered (file, " %-10s", p);
1168         }
1169
1170       /* Number.  */
1171       if (regnum < 0)
1172         fprintf_unfiltered (file, " %4s", "Nr");
1173       else
1174         fprintf_unfiltered (file, " %4d", regnum);
1175
1176       /* Relative number.  */
1177       if (regnum < 0)
1178         fprintf_unfiltered (file, " %4s", "Rel");
1179       else if (regnum < gdbarch_num_regs (gdbarch))
1180         fprintf_unfiltered (file, " %4d", regnum);
1181       else
1182         fprintf_unfiltered (file, " %4d",
1183                             (regnum - gdbarch_num_regs (gdbarch)));
1184
1185       /* Offset.  */
1186       if (regnum < 0)
1187         fprintf_unfiltered (file, " %6s  ", "Offset");
1188       else
1189         {
1190           fprintf_unfiltered (file, " %6ld",
1191                               regcache->descr->register_offset[regnum]);
1192           if (register_offset != regcache->descr->register_offset[regnum]
1193               || (regnum > 0
1194                   && (regcache->descr->register_offset[regnum]
1195                       != (regcache->descr->register_offset[regnum - 1]
1196                           + regcache->descr->sizeof_register[regnum - 1])))
1197               )
1198             {
1199               if (!footnote_register_offset)
1200                 footnote_register_offset = ++footnote_nr;
1201               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1202             }
1203           else
1204             fprintf_unfiltered (file, "  ");
1205           register_offset = (regcache->descr->register_offset[regnum]
1206                              + regcache->descr->sizeof_register[regnum]);
1207         }
1208
1209       /* Size.  */
1210       if (regnum < 0)
1211         fprintf_unfiltered (file, " %5s ", "Size");
1212       else
1213         fprintf_unfiltered (file, " %5ld",
1214                             regcache->descr->sizeof_register[regnum]);
1215
1216       /* Type.  */
1217       {
1218         const char *t;
1219
1220         if (regnum < 0)
1221           t = "Type";
1222         else
1223           {
1224             static const char blt[] = "builtin_type";
1225
1226             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1227             if (t == NULL)
1228               {
1229                 char *n;
1230
1231                 if (!footnote_register_type_name_null)
1232                   footnote_register_type_name_null = ++footnote_nr;
1233                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1234                 make_cleanup (xfree, n);
1235                 t = n;
1236               }
1237             /* Chop a leading builtin_type.  */
1238             if (strncmp (t, blt, strlen (blt)) == 0)
1239               t += strlen (blt);
1240           }
1241         fprintf_unfiltered (file, " %-15s", t);
1242       }
1243
1244       /* Leading space always present.  */
1245       fprintf_unfiltered (file, " ");
1246
1247       /* Value, raw.  */
1248       if (what_to_dump == regcache_dump_raw)
1249         {
1250           if (regnum < 0)
1251             fprintf_unfiltered (file, "Raw value");
1252           else if (regnum >= regcache->descr->nr_raw_registers)
1253             fprintf_unfiltered (file, "<cooked>");
1254           else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
1255             fprintf_unfiltered (file, "<invalid>");
1256           else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
1257             fprintf_unfiltered (file, "<unavailable>");
1258           else
1259             {
1260               regcache_raw_read (regcache, regnum, buf);
1261               fprintf_unfiltered (file, "0x");
1262               dump_endian_bytes (file,
1263                                  gdbarch_byte_order (gdbarch), buf,
1264                                  regcache->descr->sizeof_register[regnum]);
1265             }
1266         }
1267
1268       /* Value, cooked.  */
1269       if (what_to_dump == regcache_dump_cooked)
1270         {
1271           if (regnum < 0)
1272             fprintf_unfiltered (file, "Cooked value");
1273           else
1274             {
1275               enum register_status status;
1276
1277               status = regcache_cooked_read (regcache, regnum, buf);
1278               if (status == REG_UNKNOWN)
1279                 fprintf_unfiltered (file, "<invalid>");
1280               else if (status == REG_UNAVAILABLE)
1281                 fprintf_unfiltered (file, "<unavailable>");
1282               else
1283                 {
1284                   fprintf_unfiltered (file, "0x");
1285                   dump_endian_bytes (file,
1286                                      gdbarch_byte_order (gdbarch), buf,
1287                                      regcache->descr->sizeof_register[regnum]);
1288                 }
1289             }
1290         }
1291
1292       /* Group members.  */
1293       if (what_to_dump == regcache_dump_groups)
1294         {
1295           if (regnum < 0)
1296             fprintf_unfiltered (file, "Groups");
1297           else
1298             {
1299               const char *sep = "";
1300               struct reggroup *group;
1301
1302               for (group = reggroup_next (gdbarch, NULL);
1303                    group != NULL;
1304                    group = reggroup_next (gdbarch, group))
1305                 {
1306                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1307                     {
1308                       fprintf_unfiltered (file,
1309                                           "%s%s", sep, reggroup_name (group));
1310                       sep = ",";
1311                     }
1312                 }
1313             }
1314         }
1315
1316       /* Remote packet configuration.  */
1317       if (what_to_dump == regcache_dump_remote)
1318         {
1319           if (regnum < 0)
1320             {
1321               fprintf_unfiltered (file, "Rmt Nr  g/G Offset");
1322             }
1323           else if (regnum < regcache->descr->nr_raw_registers)
1324             {
1325               int pnum, poffset;
1326
1327               if (remote_register_number_and_offset (get_regcache_arch (regcache), regnum,
1328                                                      &pnum, &poffset))
1329                 fprintf_unfiltered (file, "%7d %11d", pnum, poffset);
1330             }
1331         }
1332
1333       fprintf_unfiltered (file, "\n");
1334     }
1335
1336   if (footnote_register_size)
1337     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1338                         footnote_register_size);
1339   if (footnote_register_offset)
1340     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1341                         footnote_register_offset);
1342   if (footnote_register_type_name_null)
1343     fprintf_unfiltered (file,
1344                         "*%d: Register type's name NULL.\n",
1345                         footnote_register_type_name_null);
1346   do_cleanups (cleanups);
1347 }
1348
1349 static void
1350 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1351 {
1352   if (args == NULL)
1353     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1354   else
1355     {
1356       struct cleanup *cleanups;
1357       struct ui_file *file = gdb_fopen (args, "w");
1358
1359       if (file == NULL)
1360         perror_with_name (_("maintenance print architecture"));
1361       cleanups = make_cleanup_ui_file_delete (file);
1362       regcache_dump (get_current_regcache (), file, what_to_dump);
1363       do_cleanups (cleanups);
1364     }
1365 }
1366
1367 static void
1368 maintenance_print_registers (char *args, int from_tty)
1369 {
1370   regcache_print (args, regcache_dump_none);
1371 }
1372
1373 static void
1374 maintenance_print_raw_registers (char *args, int from_tty)
1375 {
1376   regcache_print (args, regcache_dump_raw);
1377 }
1378
1379 static void
1380 maintenance_print_cooked_registers (char *args, int from_tty)
1381 {
1382   regcache_print (args, regcache_dump_cooked);
1383 }
1384
1385 static void
1386 maintenance_print_register_groups (char *args, int from_tty)
1387 {
1388   regcache_print (args, regcache_dump_groups);
1389 }
1390
1391 static void
1392 maintenance_print_remote_registers (char *args, int from_tty)
1393 {
1394   regcache_print (args, regcache_dump_remote);
1395 }
1396
1397 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1398
1399 void
1400 _initialize_regcache (void)
1401 {
1402   regcache_descr_handle
1403     = gdbarch_data_register_post_init (init_regcache_descr);
1404
1405   observer_attach_target_changed (regcache_observer_target_changed);
1406   observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1407
1408   add_com ("flushregs", class_maintenance, reg_flush_command,
1409            _("Force gdb to flush its register cache (maintainer command)"));
1410
1411   add_cmd ("registers", class_maintenance, maintenance_print_registers,
1412            _("Print the internal register configuration.\n"
1413              "Takes an optional file parameter."), &maintenanceprintlist);
1414   add_cmd ("raw-registers", class_maintenance,
1415            maintenance_print_raw_registers,
1416            _("Print the internal register configuration "
1417              "including raw values.\n"
1418              "Takes an optional file parameter."), &maintenanceprintlist);
1419   add_cmd ("cooked-registers", class_maintenance,
1420            maintenance_print_cooked_registers,
1421            _("Print the internal register configuration "
1422              "including cooked values.\n"
1423              "Takes an optional file parameter."), &maintenanceprintlist);
1424   add_cmd ("register-groups", class_maintenance,
1425            maintenance_print_register_groups,
1426            _("Print the internal register configuration "
1427              "including each register's group.\n"
1428              "Takes an optional file parameter."),
1429            &maintenanceprintlist);
1430   add_cmd ("remote-registers", class_maintenance,
1431            maintenance_print_remote_registers, _("\
1432 Print the internal register configuration including each register's\n\
1433 remote register number and buffer offset in the g/G packets.\n\
1434 Takes an optional file parameter."),
1435            &maintenanceprintlist);
1436
1437 }