gdb/regcache.c

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