contrib/gdb-7/gdb/regcache.c

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