gdb/regcache.c

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