gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
   4    2001, 2002, 2004 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbarch.h"
  27 #include "gdbcmd.h"
  28 #include "regcache.h"
  29 #include "reggroups.h"
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include "gdbcmd.h"             /* For maintenanceprintlist.  */
  33 #include "observer.h"
  34
  35 /*
  36  * DATA STRUCTURE
  37  *
  38  * Here is the actual register cache.
  39  */
  40
  41 /* Per-architecture object describing the layout of a register cache.
  42    Computed once when the architecture is created */
  43
  44 struct gdbarch_data *regcache_descr_handle;
  45
  46 struct regcache_descr
  47 {
  48   /* The architecture this descriptor belongs to.  */
  49   struct gdbarch *gdbarch;
  50
  51   /* The raw register cache.  Each raw (or hard) register is supplied
  52      by the target interface.  The raw cache should not contain
  53      redundant information - if the PC is constructed from two
  54      registers then those regigisters and not the PC lives in the raw
  55      cache.  */
  56   int nr_raw_registers;
  57   long sizeof_raw_registers;
  58   long sizeof_raw_register_valid_p;
  59
  60   /* The cooked register space.  Each cooked register in the range
  61      [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
  62      register.  The remaining [NR_RAW_REGISTERS
  63      .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
  64      both raw registers and memory by the architecture methods
  65      gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
  66   int nr_cooked_registers;
  67   long sizeof_cooked_registers;
  68   long sizeof_cooked_register_valid_p;
  69
  70   /* Offset and size (in 8 bit bytes), of reach register in the
  71      register cache.  All registers (including those in the range
  72      [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
  73      Assigning all registers an offset makes it possible to keep
  74      legacy code, such as that found in read_register_bytes() and
  75      write_register_bytes() working.  */
  76   long *register_offset;
  77   long *sizeof_register;
  78
  79   /* Cached table containing the type of each register.  */
  80   struct type **register_type;
  81 };
  82
  83 static void *
  84 init_regcache_descr (struct gdbarch *gdbarch)
  85 {
  86   int i;
  87   struct regcache_descr *descr;
  88   gdb_assert (gdbarch != NULL);
  89
  90   /* Create an initial, zero filled, table.  */
  91   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  92   descr->gdbarch = gdbarch;
  93
  94   /* Total size of the register space.  The raw registers are mapped
  95      directly onto the raw register cache while the pseudo's are
  96      either mapped onto raw-registers or memory.  */
  97   descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
  98   descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
  99
 100   /* Fill in a table of register types.  */
 101   descr->register_type
 102     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
 103   for (i = 0; i < descr->nr_cooked_registers; i++)
 104     descr->register_type[i] = gdbarch_register_type (gdbarch, i);
 105
 106   /* Construct a strictly RAW register cache.  Don't allow pseudo's
 107      into the register cache.  */
 108   descr->nr_raw_registers = NUM_REGS;
 109
 110   /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
 111      array.  This pretects GDB from erant code that accesses elements
 112      of the global register_valid_p[] array in the range [NUM_REGS
 113      .. NUM_REGS + NUM_PSEUDO_REGS).  */
 114   descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
 115
 116   /* Lay out the register cache.
 117
 118      NOTE: cagney/2002-05-22: Only register_type() is used when
 119      constructing the register cache.  It is assumed that the
 120      register's raw size, virtual size and type length are all the
 121      same.  */
 122
 123   {
 124     long offset = 0;
 125     descr->sizeof_register
 126       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 127     descr->register_offset
 128       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 129     for (i = 0; i < descr->nr_cooked_registers; i++)
 130       {
 131         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 132         descr->register_offset[i] = offset;
 133         offset += descr->sizeof_register[i];
 134         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 135       }
 136     /* Set the real size of the register cache buffer.  */
 137     descr->sizeof_cooked_registers = offset;
 138   }
 139
 140   /* FIXME: cagney/2002-05-22: Should only need to allocate space for
 141      the raw registers.  Unfortunately some code still accesses the
 142      register array directly using the global registers[].  Until that
 143      code has been purged, play safe and over allocating the register
 144      buffer.  Ulgh!  */
 145   descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
 146
 147   return descr;
 148 }
 149
 150 static struct regcache_descr *
 151 regcache_descr (struct gdbarch *gdbarch)
 152 {
 153   return gdbarch_data (gdbarch, regcache_descr_handle);
 154 }
 155
 156 /* Utility functions returning useful register attributes stored in
 157    the regcache descr.  */
 158
 159 struct type *
 160 register_type (struct gdbarch *gdbarch, int regnum)
 161 {
 162   struct regcache_descr *descr = regcache_descr (gdbarch);
 163   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 164   return descr->register_type[regnum];
 165 }
 166
 167 /* Utility functions returning useful register attributes stored in
 168    the regcache descr.  */
 169
 170 int
 171 register_size (struct gdbarch *gdbarch, int regnum)
 172 {
 173   struct regcache_descr *descr = regcache_descr (gdbarch);
 174   int size;
 175   gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
 176   size = descr->sizeof_register[regnum];
 177   return size;
 178 }
 179
 180 /* The register cache for storing raw register values.  */
 181
 182 struct regcache
 183 {
 184   struct regcache_descr *descr;
 185   /* The register buffers.  A read-only register cache can hold the
 186      full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
 187      register cache can only hold [0 .. NUM_REGS).  */
 188   char *registers;
 189   char *register_valid_p;
 190   /* Is this a read-only cache?  A read-only cache is used for saving
 191      the target's register state (e.g, across an inferior function
 192      call or just before forcing a function return).  A read-only
 193      cache can only be updated via the methods regcache_dup() and
 194      regcache_cpy().  The actual contents are determined by the
 195      reggroup_save and reggroup_restore methods.  */
 196   int readonly_p;
 197 };
 198
 199 struct regcache *
 200 regcache_xmalloc (struct gdbarch *gdbarch)
 201 {
 202   struct regcache_descr *descr;
 203   struct regcache *regcache;
 204   gdb_assert (gdbarch != NULL);
 205   descr = regcache_descr (gdbarch);
 206   regcache = XMALLOC (struct regcache);
 207   regcache->descr = descr;
 208   regcache->registers
 209     = XCALLOC (descr->sizeof_raw_registers, char);
 210   regcache->register_valid_p
 211     = XCALLOC (descr->sizeof_raw_register_valid_p, char);
 212   regcache->readonly_p = 1;
 213   return regcache;
 214 }
 215
 216 void
 217 regcache_xfree (struct regcache *regcache)
 218 {
 219   if (regcache == NULL)
 220     return;
 221   xfree (regcache->registers);
 222   xfree (regcache->register_valid_p);
 223   xfree (regcache);
 224 }
 225
 226 static void
 227 do_regcache_xfree (void *data)
 228 {
 229   regcache_xfree (data);
 230 }
 231
 232 struct cleanup *
 233 make_cleanup_regcache_xfree (struct regcache *regcache)
 234 {
 235   return make_cleanup (do_regcache_xfree, regcache);
 236 }
 237
 238 /* Return REGCACHE's architecture.  */
 239
 240 struct gdbarch *
 241 get_regcache_arch (const struct regcache *regcache)
 242 {
 243   return regcache->descr->gdbarch;
 244 }
 245
 246 /* Return  a pointer to register REGNUM's buffer cache.  */
 247
 248 static char *
 249 register_buffer (const struct regcache *regcache, int regnum)
 250 {
 251   return regcache->registers + regcache->descr->register_offset[regnum];
 252 }
 253
 254 void
 255 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 256                void *src)
 257 {
 258   struct gdbarch *gdbarch = dst->descr->gdbarch;
 259   char buf[MAX_REGISTER_SIZE];
 260   int regnum;
 261   /* The DST should be `read-only', if it wasn't then the save would
 262      end up trying to write the register values back out to the
 263      target.  */
 264   gdb_assert (dst->readonly_p);
 265   /* Clear the dest.  */
 266   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 267   memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
 268   /* Copy over any registers (identified by their membership in the
 269      save_reggroup) and mark them as valid.  The full [0 .. NUM_REGS +
 270      NUM_PSEUDO_REGS) range is checked since some architectures need
 271      to save/restore `cooked' registers that live in memory.  */
 272   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 273     {
 274       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 275         {
 276           int valid = cooked_read (src, regnum, buf);
 277           if (valid)
 278             {
 279               memcpy (register_buffer (dst, regnum), buf,
 280                       register_size (gdbarch, regnum));
 281               dst->register_valid_p[regnum] = 1;
 282             }
 283         }
 284     }
 285 }
 286
 287 void
 288 regcache_restore (struct regcache *dst,
 289                   regcache_cooked_read_ftype *cooked_read,
 290                   void *src)
 291 {
 292   struct gdbarch *gdbarch = dst->descr->gdbarch;
 293   char buf[MAX_REGISTER_SIZE];
 294   int regnum;
 295   /* The dst had better not be read-only.  If it is, the `restore'
 296      doesn't make much sense.  */
 297   gdb_assert (!dst->readonly_p);
 298   /* Copy over any registers, being careful to only restore those that
 299      were both saved and need to be restored.  The full [0 .. NUM_REGS
 300      + NUM_PSEUDO_REGS) range is checked since some architectures need
 301      to save/restore `cooked' registers that live in memory.  */
 302   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 303     {
 304       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 305         {
 306           int valid = cooked_read (src, regnum, buf);
 307           if (valid)
 308             regcache_cooked_write (dst, regnum, buf);
 309         }
 310     }
 311 }
 312
 313 static int
 314 do_cooked_read (void *src, int regnum, void *buf)
 315 {
 316   struct regcache *regcache = src;
 317   if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
 318     /* Don't even think about fetching a register from a read-only
 319        cache when the register isn't yet valid.  There isn't a target
 320        from which the register value can be fetched.  */
 321     return 0;
 322   regcache_cooked_read (regcache, regnum, buf);
 323   return 1;
 324 }
 325
 326
 327 void
 328 regcache_cpy (struct regcache *dst, struct regcache *src)
 329 {
 330   int i;
 331   char *buf;
 332   gdb_assert (src != NULL && dst != NULL);
 333   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 334   gdb_assert (src != dst);
 335   gdb_assert (src->readonly_p || dst->readonly_p);
 336   if (!src->readonly_p)
 337     regcache_save (dst, do_cooked_read, src);
 338   else if (!dst->readonly_p)
 339     regcache_restore (dst, do_cooked_read, src);
 340   else
 341     regcache_cpy_no_passthrough (dst, src);
 342 }
 343
 344 void
 345 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 346 {
 347   int i;
 348   gdb_assert (src != NULL && dst != NULL);
 349   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 350   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 351      move of data into the current_regcache().  Doing this would be
 352      silly - it would mean that valid_p would be completely invalid.  */
 353   gdb_assert (dst != current_regcache);
 354   memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
 355   memcpy (dst->register_valid_p, src->register_valid_p,
 356           dst->descr->sizeof_raw_register_valid_p);
 357 }
 358
 359 struct regcache *
 360 regcache_dup (struct regcache *src)
 361 {
 362   struct regcache *newbuf;
 363   gdb_assert (current_regcache != NULL);
 364   newbuf = regcache_xmalloc (src->descr->gdbarch);
 365   regcache_cpy (newbuf, src);
 366   return newbuf;
 367 }
 368
 369 struct regcache *
 370 regcache_dup_no_passthrough (struct regcache *src)
 371 {
 372   struct regcache *newbuf;
 373   gdb_assert (current_regcache != NULL);
 374   newbuf = regcache_xmalloc (src->descr->gdbarch);
 375   regcache_cpy_no_passthrough (newbuf, src);
 376   return newbuf;
 377 }
 378
 379 int
 380 regcache_valid_p (struct regcache *regcache, int regnum)
 381 {
 382   gdb_assert (regcache != NULL);
 383   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 384   return regcache->register_valid_p[regnum];
 385 }
 386
 387 char *
 388 deprecated_grub_regcache_for_registers (struct regcache *regcache)
 389 {
 390   return regcache->registers;
 391 }
 392
 393 /* Global structure containing the current regcache.  */
 394 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
 395    deprecated_register_valid[] currently point into this structure.  */
 396 struct regcache *current_regcache;
 397
 398 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 399    recording if the register values have been changed (eg. by the
 400    user).  Therefore all registers must be written back to the
 401    target when appropriate.  */
 402
 403 /* REGISTERS contains the cached register values (in target byte order). */
 404
 405 char *deprecated_registers;
 406
 407 /* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
 408                      1 if it has been fetched, and
 409                     -1 if the register value was not available.
 410
 411    "Not available" indicates that the target is not not able to supply
 412    the register at this state.  The register may become available at a
 413    later time (after the next resume).  This often occures when GDB is
 414    manipulating a target that contains only a snapshot of the entire
 415    system being debugged - some of the registers in such a system may
 416    not have been saved.  */
 417
 418 signed char *deprecated_register_valid;
 419
 420 /* The thread/process associated with the current set of registers. */
 421
 422 static ptid_t registers_ptid;
 423
 424 /*
 425  * FUNCTIONS:
 426  */
 427
 428 /* REGISTER_CACHED()
 429
 430    Returns 0 if the value is not in the cache (needs fetch).
 431           >0 if the value is in the cache.
 432           <0 if the value is permanently unavailable (don't ask again).  */
 433
 434 int
 435 register_cached (int regnum)
 436 {
 437   return deprecated_register_valid[regnum];
 438 }
 439
 440 /* Record that REGNUM's value is cached if STATE is >0, uncached but
 441    fetchable if STATE is 0, and uncached and unfetchable if STATE is <0.  */
 442
 443 void
 444 set_register_cached (int regnum, int state)
 445 {
 446   gdb_assert (regnum >= 0);
 447   gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
 448   current_regcache->register_valid_p[regnum] = state;
 449 }
 450
 451 /* Observer for the target_changed event.  */
 452
 453 void
 454 regcache_observer_target_changed (struct target_ops *target)
 455 {
 456   registers_changed ();
 457 }
 458
 459 /* Low level examining and depositing of registers.
 460
 461    The caller is responsible for making sure that the inferior is
 462    stopped before calling the fetching routines, or it will get
 463    garbage.  (a change from GDB version 3, in which the caller got the
 464    value from the last stop).  */
 465
 466 /* REGISTERS_CHANGED ()
 467
 468    Indicate that registers may have changed, so invalidate the cache.  */
 469
 470 void
 471 registers_changed (void)
 472 {
 473   int i;
 474
 475   registers_ptid = pid_to_ptid (-1);
 476
 477   /* Force cleanup of any alloca areas if using C alloca instead of
 478      a builtin alloca.  This particular call is used to clean up
 479      areas allocated by low level target code which may build up
 480      during lengthy interactions between gdb and the target before
 481      gdb gives control to the user (ie watchpoints).  */
 482   alloca (0);
 483
 484   for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
 485     set_register_cached (i, 0);
 486
 487   if (deprecated_registers_changed_hook)
 488     deprecated_registers_changed_hook ();
 489 }
 490
 491 /* DEPRECATED_REGISTERS_FETCHED ()
 492
 493    Indicate that all registers have been fetched, so mark them all valid.  */
 494
 495 /* FIXME: cagney/2001-12-04: This function is DEPRECATED.  The target
 496    code was blatting the registers[] array and then calling this.
 497    Since targets should only be using regcache_raw_supply() the need for
 498    this function/hack is eliminated.  */
 499
 500 void
 501 deprecated_registers_fetched (void)
 502 {
 503   int i;
 504
 505   for (i = 0; i < NUM_REGS; i++)
 506     set_register_cached (i, 1);
 507   /* Do not assume that the pseudo-regs have also been fetched.
 508      Fetching all real regs NEVER accounts for pseudo-regs.  */
 509 }
 510
 511 /* deprecated_read_register_bytes and deprecated_write_register_bytes
 512    are generally a *BAD* idea.  They are inefficient because they need
 513    to check for partial updates, which can only be done by scanning
 514    through all of the registers and seeing if the bytes that are being
 515    read/written fall inside of an invalid register.  [The main reason
 516    this is necessary is that register sizes can vary, so a simple
 517    index won't suffice.]  It is far better to call read_register_gen
 518    and write_register_gen if you want to get at the raw register
 519    contents, as it only takes a regnum as an argument, and therefore
 520    can't do a partial register update.
 521
 522    Prior to the recent fixes to check for partial updates, both read
 523    and deprecated_write_register_bytes always checked to see if any
 524    registers were stale, and then called target_fetch_registers (-1)
 525    to update the whole set.  This caused really slowed things down for
 526    remote targets.  */
 527
 528 /* Copy INLEN bytes of consecutive data from registers
 529    starting with the INREGBYTE'th byte of register data
 530    into memory at MYADDR.  */
 531
 532 void
 533 deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
 534 {
 535   int in_end = in_start + in_len;
 536   int regnum;
 537   char reg_buf[MAX_REGISTER_SIZE];
 538
 539   /* See if we are trying to read bytes from out-of-date registers.  If so,
 540      update just those registers.  */
 541
 542   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
 543     {
 544       int reg_start;
 545       int reg_end;
 546       int reg_len;
 547       int start;
 548       int end;
 549       int byte;
 550
 551       reg_start = DEPRECATED_REGISTER_BYTE (regnum);
 552       reg_len = register_size (current_gdbarch, regnum);
 553       reg_end = reg_start + reg_len;
 554
 555       if (reg_end <= in_start || in_end <= reg_start)
 556         /* The range the user wants to read doesn't overlap with regnum.  */
 557         continue;
 558
 559       if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
 560         /* Force the cache to fetch the entire register.  */
 561         deprecated_read_register_gen (regnum, reg_buf);
 562       else
 563         /* Legacy note: even though this register is ``invalid'' we
 564            still need to return something.  It would appear that some
 565            code relies on apparent gaps in the register array also
 566            being returned.  */
 567         /* FIXME: cagney/2001-08-18: This is just silly.  It defeats
 568            the entire register read/write flow of control.  Must
 569            resist temptation to return 0xdeadbeef.  */
 570         memcpy (reg_buf, &deprecated_registers[reg_start], reg_len);
 571
 572       /* Legacy note: This function, for some reason, allows a NULL
 573          input buffer.  If the buffer is NULL, the registers are still
 574          fetched, just the final transfer is skipped. */
 575       if (in_buf == NULL)
 576         continue;
 577
 578       /* start = max (reg_start, in_start) */
 579       if (reg_start > in_start)
 580         start = reg_start;
 581       else
 582         start = in_start;
 583
 584       /* end = min (reg_end, in_end) */
 585       if (reg_end < in_end)
 586         end = reg_end;
 587       else
 588         end = in_end;
 589
 590       /* Transfer just the bytes common to both IN_BUF and REG_BUF */
 591       for (byte = start; byte < end; byte++)
 592         {
 593           in_buf[byte - in_start] = reg_buf[byte - reg_start];
 594         }
 595     }
 596 }
 597
 598 void
 599 regcache_raw_read (struct regcache *regcache, int regnum, void *buf)
 600 {
 601   gdb_assert (regcache != NULL && buf != NULL);
 602   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 603   /* Make certain that the register cache is up-to-date with respect
 604      to the current thread.  This switching shouldn't be necessary
 605      only there is still only one target side register cache.  Sigh!
 606      On the bright side, at least there is a regcache object.  */
 607   if (!regcache->readonly_p)
 608     {
 609       gdb_assert (regcache == current_regcache);
 610       if (! ptid_equal (registers_ptid, inferior_ptid))
 611         {
 612           registers_changed ();
 613           registers_ptid = inferior_ptid;
 614         }
 615       if (!register_cached (regnum))
 616         target_fetch_registers (regnum);
 617     }
 618   /* Copy the value directly into the register cache.  */
 619   memcpy (buf, register_buffer (regcache, regnum),
 620           regcache->descr->sizeof_register[regnum]);
 621 }
 622
 623 void
 624 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 625 {
 626   char *buf;
 627   gdb_assert (regcache != NULL);
 628   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 629   buf = alloca (regcache->descr->sizeof_register[regnum]);
 630   regcache_raw_read (regcache, regnum, buf);
 631   (*val) = extract_signed_integer (buf,
 632                                    regcache->descr->sizeof_register[regnum]);
 633 }
 634
 635 void
 636 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 637                             ULONGEST *val)
 638 {
 639   char *buf;
 640   gdb_assert (regcache != NULL);
 641   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 642   buf = alloca (regcache->descr->sizeof_register[regnum]);
 643   regcache_raw_read (regcache, regnum, buf);
 644   (*val) = extract_unsigned_integer (buf,
 645                                      regcache->descr->sizeof_register[regnum]);
 646 }
 647
 648 void
 649 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 650 {
 651   void *buf;
 652   gdb_assert (regcache != NULL);
 653   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 654   buf = alloca (regcache->descr->sizeof_register[regnum]);
 655   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 656   regcache_raw_write (regcache, regnum, buf);
 657 }
 658
 659 void
 660 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 661                              ULONGEST val)
 662 {
 663   void *buf;
 664   gdb_assert (regcache != NULL);
 665   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 666   buf = alloca (regcache->descr->sizeof_register[regnum]);
 667   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 668   regcache_raw_write (regcache, regnum, buf);
 669 }
 670
 671 void
 672 deprecated_read_register_gen (int regnum, char *buf)
 673 {
 674   gdb_assert (current_regcache != NULL);
 675   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 676   regcache_cooked_read (current_regcache, regnum, buf);
 677 }
 678
 679 void
 680 regcache_cooked_read (struct regcache *regcache, int regnum, void *buf)
 681 {
 682   gdb_assert (regnum >= 0);
 683   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 684   if (regnum < regcache->descr->nr_raw_registers)
 685     regcache_raw_read (regcache, regnum, buf);
 686   else if (regcache->readonly_p
 687            && regnum < regcache->descr->nr_cooked_registers
 688            && regcache->register_valid_p[regnum])
 689     /* Read-only register cache, perhaps the cooked value was cached?  */
 690     memcpy (buf, register_buffer (regcache, regnum),
 691             regcache->descr->sizeof_register[regnum]);
 692   else
 693     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 694                                   regnum, buf);
 695 }
 696
 697 void
 698 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 699                              LONGEST *val)
 700 {
 701   char *buf;
 702   gdb_assert (regcache != NULL);
 703   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 704   buf = alloca (regcache->descr->sizeof_register[regnum]);
 705   regcache_cooked_read (regcache, regnum, buf);
 706   (*val) = extract_signed_integer (buf,
 707                                    regcache->descr->sizeof_register[regnum]);
 708 }
 709
 710 void
 711 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 712                                ULONGEST *val)
 713 {
 714   char *buf;
 715   gdb_assert (regcache != NULL);
 716   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 717   buf = alloca (regcache->descr->sizeof_register[regnum]);
 718   regcache_cooked_read (regcache, regnum, buf);
 719   (*val) = extract_unsigned_integer (buf,
 720                                      regcache->descr->sizeof_register[regnum]);
 721 }
 722
 723 void
 724 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 725                               LONGEST val)
 726 {
 727   void *buf;
 728   gdb_assert (regcache != NULL);
 729   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 730   buf = alloca (regcache->descr->sizeof_register[regnum]);
 731   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 732   regcache_cooked_write (regcache, regnum, buf);
 733 }
 734
 735 void
 736 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 737                                 ULONGEST val)
 738 {
 739   void *buf;
 740   gdb_assert (regcache != NULL);
 741   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 742   buf = alloca (regcache->descr->sizeof_register[regnum]);
 743   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 744   regcache_cooked_write (regcache, regnum, buf);
 745 }
 746
 747 void
 748 regcache_raw_write (struct regcache *regcache, int regnum, const void *buf)
 749 {
 750   gdb_assert (regcache != NULL && buf != NULL);
 751   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 752   gdb_assert (!regcache->readonly_p);
 753
 754   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 755      change the registers array if something writes to this register.  */
 756   if (CANNOT_STORE_REGISTER (regnum))
 757     return;
 758
 759   /* Make certain that the correct cache is selected.  */
 760   gdb_assert (regcache == current_regcache);
 761   if (! ptid_equal (registers_ptid, inferior_ptid))
 762     {
 763       registers_changed ();
 764       registers_ptid = inferior_ptid;
 765     }
 766
 767   /* If we have a valid copy of the register, and new value == old
 768      value, then don't bother doing the actual store. */
 769   if (regcache_valid_p (regcache, regnum)
 770       && (memcmp (register_buffer (regcache, regnum), buf,
 771                   regcache->descr->sizeof_register[regnum]) == 0))
 772     return;
 773
 774   target_prepare_to_store ();
 775   memcpy (register_buffer (regcache, regnum), buf,
 776           regcache->descr->sizeof_register[regnum]);
 777   regcache->register_valid_p[regnum] = 1;
 778   target_store_registers (regnum);
 779 }
 780
 781 void
 782 deprecated_write_register_gen (int regnum, char *buf)
 783 {
 784   gdb_assert (current_regcache != NULL);
 785   gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
 786   regcache_cooked_write (current_regcache, regnum, buf);
 787 }
 788
 789 void
 790 regcache_cooked_write (struct regcache *regcache, int regnum, const void *buf)
 791 {
 792   gdb_assert (regnum >= 0);
 793   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 794   if (regnum < regcache->descr->nr_raw_registers)
 795     regcache_raw_write (regcache, regnum, buf);
 796   else
 797     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 798                                    regnum, buf);
 799 }
 800
 801 /* Copy INLEN bytes of consecutive data from memory at MYADDR
 802    into registers starting with the MYREGSTART'th byte of register data.  */
 803
 804 void
 805 deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
 806 {
 807   int myregend = myregstart + inlen;
 808   int regnum;
 809
 810   target_prepare_to_store ();
 811
 812   /* Scan through the registers updating any that are covered by the
 813      range myregstart<=>myregend using write_register_gen, which does
 814      nice things like handling threads, and avoiding updates when the
 815      new and old contents are the same.  */
 816
 817   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
 818     {
 819       int regstart, regend;
 820
 821       regstart = DEPRECATED_REGISTER_BYTE (regnum);
 822       regend = regstart + register_size (current_gdbarch, regnum);
 823
 824       /* Is this register completely outside the range the user is writing?  */
 825       if (myregend <= regstart || regend <= myregstart)
 826         /* do nothing */ ;
 827
 828       /* Is this register completely within the range the user is writing?  */
 829       else if (myregstart <= regstart && regend <= myregend)
 830         deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart));
 831
 832       /* The register partially overlaps the range being written.  */
 833       else
 834         {
 835           char regbuf[MAX_REGISTER_SIZE];
 836           /* What's the overlap between this register's bytes and
 837              those the caller wants to write?  */
 838           int overlapstart = max (regstart, myregstart);
 839           int overlapend   = min (regend,   myregend);
 840
 841           /* We may be doing a partial update of an invalid register.
 842              Update it from the target before scribbling on it.  */
 843           deprecated_read_register_gen (regnum, regbuf);
 844
 845           memcpy (&deprecated_registers[overlapstart],
 846                   myaddr + (overlapstart - myregstart),
 847                   overlapend - overlapstart);
 848
 849           target_store_registers (regnum);
 850         }
 851     }
 852 }
 853
 854 /* Perform a partial register transfer using a read, modify, write
 855    operation.  */
 856
 857 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 858                                     void *buf);
 859 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 860                                      const void *buf);
 861
 862 static void
 863 regcache_xfer_part (struct regcache *regcache, int regnum,
 864                     int offset, int len, void *in, const void *out,
 865                     regcache_read_ftype *read, regcache_write_ftype *write)
 866 {
 867   struct regcache_descr *descr = regcache->descr;
 868   bfd_byte reg[MAX_REGISTER_SIZE];
 869   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 870   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 871   /* Something to do?  */
 872   if (offset + len == 0)
 873     return;
 874   /* Read (when needed) ... */
 875   if (in != NULL
 876       || offset > 0
 877       || offset + len < descr->sizeof_register[regnum])
 878     {
 879       gdb_assert (read != NULL);
 880       read (regcache, regnum, reg);
 881     }
 882   /* ... modify ... */
 883   if (in != NULL)
 884     memcpy (in, reg + offset, len);
 885   if (out != NULL)
 886     memcpy (reg + offset, out, len);
 887   /* ... write (when needed).  */
 888   if (out != NULL)
 889     {
 890       gdb_assert (write != NULL);
 891       write (regcache, regnum, reg);
 892     }
 893 }
 894
 895 void
 896 regcache_raw_read_part (struct regcache *regcache, int regnum,
 897                         int offset, int len, void *buf)
 898 {
 899   struct regcache_descr *descr = regcache->descr;
 900   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 901   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 902                       regcache_raw_read, regcache_raw_write);
 903 }
 904
 905 void
 906 regcache_raw_write_part (struct regcache *regcache, int regnum,
 907                          int offset, int len, const void *buf)
 908 {
 909   struct regcache_descr *descr = regcache->descr;
 910   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 911   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 912                       regcache_raw_read, regcache_raw_write);
 913 }
 914
 915 void
 916 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 917                            int offset, int len, void *buf)
 918 {
 919   struct regcache_descr *descr = regcache->descr;
 920   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 921   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 922                       regcache_cooked_read, regcache_cooked_write);
 923 }
 924
 925 void
 926 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 927                             int offset, int len, const void *buf)
 928 {
 929   struct regcache_descr *descr = regcache->descr;
 930   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 931   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 932                       regcache_cooked_read, regcache_cooked_write);
 933 }
 934
 935 /* Hack to keep code that view the register buffer as raw bytes
 936    working.  */
 937
 938 int
 939 register_offset_hack (struct gdbarch *gdbarch, int regnum)
 940 {
 941   struct regcache_descr *descr = regcache_descr (gdbarch);
 942   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 943   return descr->register_offset[regnum];
 944 }
 945
 946 /* Hack to keep code using register_bytes working.  */
 947
 948 int
 949 deprecated_register_bytes (void)
 950 {
 951   return current_regcache->descr->sizeof_raw_registers;
 952 }
 953
 954 /* Return the contents of register REGNUM as an unsigned integer.  */
 955
 956 ULONGEST
 957 read_register (int regnum)
 958 {
 959   char *buf = alloca (register_size (current_gdbarch, regnum));
 960   deprecated_read_register_gen (regnum, buf);
 961   return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
 962 }
 963
 964 ULONGEST
 965 read_register_pid (int regnum, ptid_t ptid)
 966 {
 967   ptid_t save_ptid;
 968   int save_pid;
 969   CORE_ADDR retval;
 970
 971   if (ptid_equal (ptid, inferior_ptid))
 972     return read_register (regnum);
 973
 974   save_ptid = inferior_ptid;
 975
 976   inferior_ptid = ptid;
 977
 978   retval = read_register (regnum);
 979
 980   inferior_ptid = save_ptid;
 981
 982   return retval;
 983 }
 984
 985 /* Store VALUE into the raw contents of register number REGNUM.  */
 986
 987 void
 988 write_register (int regnum, LONGEST val)
 989 {
 990   void *buf;
 991   int size;
 992   size = register_size (current_gdbarch, regnum);
 993   buf = alloca (size);
 994   store_signed_integer (buf, size, (LONGEST) val);
 995   deprecated_write_register_gen (regnum, buf);
 996 }
 997
 998 void
 999 write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
1000 {
1001   ptid_t save_ptid;
1002
1003   if (ptid_equal (ptid, inferior_ptid))
1004     {
1005       write_register (regnum, val);
1006       return;
1007     }
1008
1009   save_ptid = inferior_ptid;
1010
1011   inferior_ptid = ptid;
1012
1013   write_register (regnum, val);
1014
1015   inferior_ptid = save_ptid;
1016 }
1017
1018 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
1019
1020 void
1021 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1022 {
1023   void *regbuf;
1024   size_t size;
1025
1026   gdb_assert (regcache != NULL);
1027   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1028   gdb_assert (!regcache->readonly_p);
1029
1030   /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
1031      CURRENT_REGCACHE specially here.  */
1032   if (regcache == current_regcache
1033       && !ptid_equal (registers_ptid, inferior_ptid))
1034     {
1035       registers_changed ();
1036       registers_ptid = inferior_ptid;
1037     }
1038
1039   regbuf = register_buffer (regcache, regnum);
1040   size = regcache->descr->sizeof_register[regnum];
1041
1042   if (buf)
1043     memcpy (regbuf, buf, size);
1044   else
1045     memset (regbuf, 0, size);
1046
1047   /* Mark the register as cached.  */
1048   regcache->register_valid_p[regnum] = 1;
1049 }
1050
1051 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
1052
1053 void
1054 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1055 {
1056   const void *regbuf;
1057   size_t size;
1058
1059   gdb_assert (regcache != NULL && buf != NULL);
1060   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1061
1062   regbuf = register_buffer (regcache, regnum);
1063   size = regcache->descr->sizeof_register[regnum];
1064   memcpy (buf, regbuf, size);
1065 }
1066
1067
1068 /* read_pc, write_pc, read_sp, deprecated_read_fp, etc.  Special
1069    handling for registers PC, SP, and FP.  */
1070
1071 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
1072    read_sp(), and deprecated_read_fp(), will eventually be replaced by
1073    per-frame methods.  Instead of relying on the global INFERIOR_PTID,
1074    they will use the contextual information provided by the FRAME.
1075    These functions do not belong in the register cache.  */
1076
1077 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
1078    write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
1079    be replaced by something that does not rely on global state.  But
1080    what?  */
1081
1082 CORE_ADDR
1083 read_pc_pid (ptid_t ptid)
1084 {
1085   ptid_t saved_inferior_ptid;
1086   CORE_ADDR pc_val;
1087
1088   /* In case ptid != inferior_ptid. */
1089   saved_inferior_ptid = inferior_ptid;
1090   inferior_ptid = ptid;
1091
1092   if (TARGET_READ_PC_P ())
1093     pc_val = TARGET_READ_PC (ptid);
1094   /* Else use per-frame method on get_current_frame.  */
1095   else if (PC_REGNUM >= 0)
1096     {
1097       CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
1098       pc_val = ADDR_BITS_REMOVE (raw_val);
1099     }
1100   else
1101     internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
1102
1103   inferior_ptid = saved_inferior_ptid;
1104   return pc_val;
1105 }
1106
1107 CORE_ADDR
1108 read_pc (void)
1109 {
1110   return read_pc_pid (inferior_ptid);
1111 }
1112
1113 void
1114 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
1115 {
1116   if (PC_REGNUM >= 0)
1117     write_register_pid (PC_REGNUM, pc, ptid);
1118   else
1119     internal_error (__FILE__, __LINE__,
1120                     "generic_target_write_pc");
1121 }
1122
1123 void
1124 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1125 {
1126   ptid_t saved_inferior_ptid;
1127
1128   /* In case ptid != inferior_ptid. */
1129   saved_inferior_ptid = inferior_ptid;
1130   inferior_ptid = ptid;
1131
1132   TARGET_WRITE_PC (pc, ptid);
1133
1134   inferior_ptid = saved_inferior_ptid;
1135 }
1136
1137 void
1138 write_pc (CORE_ADDR pc)
1139 {
1140   write_pc_pid (pc, inferior_ptid);
1141 }
1142
1143 /* Cope with strage ways of getting to the stack and frame pointers */
1144
1145 CORE_ADDR
1146 read_sp (void)
1147 {
1148   if (TARGET_READ_SP_P ())
1149     return TARGET_READ_SP ();
1150   else if (gdbarch_unwind_sp_p (current_gdbarch))
1151     return get_frame_sp (get_current_frame ());
1152   else if (SP_REGNUM >= 0)
1153     /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1154        about the architecture so put it at the end.  */
1155     return read_register (SP_REGNUM);
1156   internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
1157 }
1158
1159 void
1160 deprecated_write_sp (CORE_ADDR val)
1161 {
1162   gdb_assert (SP_REGNUM >= 0);
1163   write_register (SP_REGNUM, val);
1164 }
1165
1166 CORE_ADDR
1167 deprecated_read_fp (void)
1168 {
1169   if (DEPRECATED_FP_REGNUM >= 0)
1170     return read_register (DEPRECATED_FP_REGNUM);
1171   else
1172     internal_error (__FILE__, __LINE__, "deprecated_read_fp");
1173 }
1174
1175 static void
1176 reg_flush_command (char *command, int from_tty)
1177 {
1178   /* Force-flush the register cache.  */
1179   registers_changed ();
1180   if (from_tty)
1181     printf_filtered ("Register cache flushed.\n");
1182 }
1183
1184 static void
1185 build_regcache (void)
1186 {
1187   current_regcache = regcache_xmalloc (current_gdbarch);
1188   current_regcache->readonly_p = 0;
1189   deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
1190   deprecated_register_valid = current_regcache->register_valid_p;
1191 }
1192
1193 static void
1194 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1195                    const unsigned char *buf, long len)
1196 {
1197   int i;
1198   switch (endian)
1199     {
1200     case BFD_ENDIAN_BIG:
1201       for (i = 0; i < len; i++)
1202         fprintf_unfiltered (file, "%02x", buf[i]);
1203       break;
1204     case BFD_ENDIAN_LITTLE:
1205       for (i = len - 1; i >= 0; i--)
1206         fprintf_unfiltered (file, "%02x", buf[i]);
1207       break;
1208     default:
1209       internal_error (__FILE__, __LINE__, "Bad switch");
1210     }
1211 }
1212
1213 enum regcache_dump_what
1214 {
1215   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1216 };
1217
1218 static void
1219 regcache_dump (struct regcache *regcache, struct ui_file *file,
1220                enum regcache_dump_what what_to_dump)
1221 {
1222   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1223   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1224   int regnum;
1225   int footnote_nr = 0;
1226   int footnote_register_size = 0;
1227   int footnote_register_offset = 0;
1228   int footnote_register_type_name_null = 0;
1229   long register_offset = 0;
1230   unsigned char buf[MAX_REGISTER_SIZE];
1231
1232 #if 0
1233   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1234                       regcache->descr->nr_raw_registers);
1235   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1236                       regcache->descr->nr_cooked_registers);
1237   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1238                       regcache->descr->sizeof_raw_registers);
1239   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1240                       regcache->descr->sizeof_raw_register_valid_p);
1241   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1242   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1243 #endif
1244
1245   gdb_assert (regcache->descr->nr_cooked_registers
1246               == (NUM_REGS + NUM_PSEUDO_REGS));
1247
1248   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1249     {
1250       /* Name.  */
1251       if (regnum < 0)
1252         fprintf_unfiltered (file, " %-10s", "Name");
1253       else
1254         {
1255           const char *p = REGISTER_NAME (regnum);
1256           if (p == NULL)
1257             p = "";
1258           else if (p[0] == '\0')
1259             p = "''";
1260           fprintf_unfiltered (file, " %-10s", p);
1261         }
1262
1263       /* Number.  */
1264       if (regnum < 0)
1265         fprintf_unfiltered (file, " %4s", "Nr");
1266       else
1267         fprintf_unfiltered (file, " %4d", regnum);
1268
1269       /* Relative number.  */
1270       if (regnum < 0)
1271         fprintf_unfiltered (file, " %4s", "Rel");
1272       else if (regnum < NUM_REGS)
1273         fprintf_unfiltered (file, " %4d", regnum);
1274       else
1275         fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1276
1277       /* Offset.  */
1278       if (regnum < 0)
1279         fprintf_unfiltered (file, " %6s  ", "Offset");
1280       else
1281         {
1282           fprintf_unfiltered (file, " %6ld",
1283                               regcache->descr->register_offset[regnum]);
1284           if (register_offset != regcache->descr->register_offset[regnum]
1285               || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
1286               || (regnum > 0
1287                   && (regcache->descr->register_offset[regnum]
1288                       != (regcache->descr->register_offset[regnum - 1]
1289                           + regcache->descr->sizeof_register[regnum - 1])))
1290               )
1291             {
1292               if (!footnote_register_offset)
1293                 footnote_register_offset = ++footnote_nr;
1294               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1295             }
1296           else
1297             fprintf_unfiltered (file, "  ");
1298           register_offset = (regcache->descr->register_offset[regnum]
1299                              + regcache->descr->sizeof_register[regnum]);
1300         }
1301
1302       /* Size.  */
1303       if (regnum < 0)
1304         fprintf_unfiltered (file, " %5s ", "Size");
1305       else
1306         fprintf_unfiltered (file, " %5ld",
1307                             regcache->descr->sizeof_register[regnum]);
1308
1309       /* Type.  */
1310       {
1311         const char *t;
1312         if (regnum < 0)
1313           t = "Type";
1314         else
1315           {
1316             static const char blt[] = "builtin_type";
1317             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1318             if (t == NULL)
1319               {
1320                 char *n;
1321                 if (!footnote_register_type_name_null)
1322                   footnote_register_type_name_null = ++footnote_nr;
1323                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1324                 make_cleanup (xfree, n);
1325                 t = n;
1326               }
1327             /* Chop a leading builtin_type.  */
1328             if (strncmp (t, blt, strlen (blt)) == 0)
1329               t += strlen (blt);
1330           }
1331         fprintf_unfiltered (file, " %-15s", t);
1332       }
1333
1334       /* Leading space always present.  */
1335       fprintf_unfiltered (file, " ");
1336
1337       /* Value, raw.  */
1338       if (what_to_dump == regcache_dump_raw)
1339         {
1340           if (regnum < 0)
1341             fprintf_unfiltered (file, "Raw value");
1342           else if (regnum >= regcache->descr->nr_raw_registers)
1343             fprintf_unfiltered (file, "<cooked>");
1344           else if (!regcache_valid_p (regcache, regnum))
1345             fprintf_unfiltered (file, "<invalid>");
1346           else
1347             {
1348               regcache_raw_read (regcache, regnum, buf);
1349               fprintf_unfiltered (file, "0x");
1350               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1351                                  regcache->descr->sizeof_register[regnum]);
1352             }
1353         }
1354
1355       /* Value, cooked.  */
1356       if (what_to_dump == regcache_dump_cooked)
1357         {
1358           if (regnum < 0)
1359             fprintf_unfiltered (file, "Cooked value");
1360           else
1361             {
1362               regcache_cooked_read (regcache, regnum, buf);
1363               fprintf_unfiltered (file, "0x");
1364               dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1365                                  regcache->descr->sizeof_register[regnum]);
1366             }
1367         }
1368
1369       /* Group members.  */
1370       if (what_to_dump == regcache_dump_groups)
1371         {
1372           if (regnum < 0)
1373             fprintf_unfiltered (file, "Groups");
1374           else
1375             {
1376               const char *sep = "";
1377               struct reggroup *group;
1378               for (group = reggroup_next (gdbarch, NULL);
1379                    group != NULL;
1380                    group = reggroup_next (gdbarch, group))
1381                 {
1382                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1383                     {
1384                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1385                       sep = ",";
1386                     }
1387                 }
1388             }
1389         }
1390
1391       fprintf_unfiltered (file, "\n");
1392     }
1393
1394   if (footnote_register_size)
1395     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1396                         footnote_register_size);
1397   if (footnote_register_offset)
1398     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1399                         footnote_register_offset);
1400   if (footnote_register_type_name_null)
1401     fprintf_unfiltered (file,
1402                         "*%d: Register type's name NULL.\n",
1403                         footnote_register_type_name_null);
1404   do_cleanups (cleanups);
1405 }
1406
1407 static void
1408 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1409 {
1410   if (args == NULL)
1411     regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1412   else
1413     {
1414       struct ui_file *file = gdb_fopen (args, "w");
1415       if (file == NULL)
1416         perror_with_name ("maintenance print architecture");
1417       regcache_dump (current_regcache, file, what_to_dump);
1418       ui_file_delete (file);
1419     }
1420 }
1421
1422 static void
1423 maintenance_print_registers (char *args, int from_tty)
1424 {
1425   regcache_print (args, regcache_dump_none);
1426 }
1427
1428 static void
1429 maintenance_print_raw_registers (char *args, int from_tty)
1430 {
1431   regcache_print (args, regcache_dump_raw);
1432 }
1433
1434 static void
1435 maintenance_print_cooked_registers (char *args, int from_tty)
1436 {
1437   regcache_print (args, regcache_dump_cooked);
1438 }
1439
1440 static void
1441 maintenance_print_register_groups (char *args, int from_tty)
1442 {
1443   regcache_print (args, regcache_dump_groups);
1444 }
1445
1446 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1447
1448 void
1449 _initialize_regcache (void)
1450 {
1451   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1452   DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1453   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers);
1454   DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid);
1455   deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1456
1457   observer_attach_target_changed (regcache_observer_target_changed);
1458
1459   add_com ("flushregs", class_maintenance, reg_flush_command,
1460            "Force gdb to flush its register cache (maintainer command)");
1461
1462    /* Initialize the thread/process associated with the current set of
1463       registers.  For now, -1 is special, and means `no current process'.  */
1464   registers_ptid = pid_to_ptid (-1);
1465
1466   add_cmd ("registers", class_maintenance,
1467            maintenance_print_registers,
1468            "Print the internal register configuration.\
1469 Takes an optional file parameter.",
1470            &maintenanceprintlist);
1471   add_cmd ("raw-registers", class_maintenance,
1472            maintenance_print_raw_registers,
1473            "Print the internal register configuration including raw values.\
1474 Takes an optional file parameter.",
1475            &maintenanceprintlist);
1476   add_cmd ("cooked-registers", class_maintenance,
1477            maintenance_print_cooked_registers,
1478            "Print the internal register configuration including cooked values.\
1479 Takes an optional file parameter.",
1480            &maintenanceprintlist);
1481   add_cmd ("register-groups", class_maintenance,
1482            maintenance_print_register_groups,
1483            "Print the internal register configuration including each register's group.\
1484 Takes an optional file parameter.",
1485            &maintenanceprintlist);
1486
1487 }