gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
   4    2002, 2004, 2007 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "gdbarch.h"
  25 #include "gdbcmd.h"
  26 #include "regcache.h"
  27 #include "reggroups.h"
  28 #include "gdb_assert.h"
  29 #include "gdb_string.h"
  30 #include "gdbcmd.h"             /* For maintenanceprintlist.  */
  31 #include "observer.h"
  32
  33 /*
  34  * DATA STRUCTURE
  35  *
  36  * Here is the actual register cache.
  37  */
  38
  39 /* Per-architecture object describing the layout of a register cache.
  40    Computed once when the architecture is created */
  41
  42 struct gdbarch_data *regcache_descr_handle;
  43
  44 struct regcache_descr
  45 {
  46   /* The architecture this descriptor belongs to.  */
  47   struct gdbarch *gdbarch;
  48
  49   /* The raw register cache.  Each raw (or hard) register is supplied
  50      by the target interface.  The raw cache should not contain
  51      redundant information - if the PC is constructed from two
  52      registers then those registers and not the PC lives in the raw
  53      cache.  */
  54   int nr_raw_registers;
  55   long sizeof_raw_registers;
  56   long sizeof_raw_register_valid_p;
  57
  58   /* The cooked register space.  Each cooked register in the range
  59      [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
  60      register.  The remaining [NR_RAW_REGISTERS
  61      .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
  62      both raw registers and memory by the architecture methods
  63      gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
  64   int nr_cooked_registers;
  65   long sizeof_cooked_registers;
  66   long sizeof_cooked_register_valid_p;
  67
  68   /* Offset and size (in 8 bit bytes), of reach register in the
  69      register cache.  All registers (including those in the range
  70      [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
  71      Assigning all registers an offset makes it possible to keep
  72      legacy code, such as that found in read_register_bytes() and
  73      write_register_bytes() working.  */
  74   long *register_offset;
  75   long *sizeof_register;
  76
  77   /* Cached table containing the type of each register.  */
  78   struct type **register_type;
  79 };
  80
  81 static void *
  82 init_regcache_descr (struct gdbarch *gdbarch)
  83 {
  84   int i;
  85   struct regcache_descr *descr;
  86   gdb_assert (gdbarch != NULL);
  87
  88   /* Create an initial, zero filled, table.  */
  89   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  90   descr->gdbarch = gdbarch;
  91
  92   /* Total size of the register space.  The raw registers are mapped
  93      directly onto the raw register cache while the pseudo's are
  94      either mapped onto raw-registers or memory.  */
  95   descr->nr_cooked_registers = gdbarch_num_regs (current_gdbarch)
  96                                + gdbarch_num_pseudo_regs (current_gdbarch);
  97   descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
  98                                           + gdbarch_num_pseudo_regs
  99                                               (current_gdbarch);
 100
 101   /* Fill in a table of register types.  */
 102   descr->register_type
 103     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
 104   for (i = 0; i < descr->nr_cooked_registers; i++)
 105     descr->register_type[i] = gdbarch_register_type (gdbarch, i);
 106
 107   /* Construct a strictly RAW register cache.  Don't allow pseudo's
 108      into the register cache.  */
 109   descr->nr_raw_registers = gdbarch_num_regs (current_gdbarch);
 110
 111   /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
 112      array.  This pretects GDB from erant code that accesses elements
 113      of the global register_valid_p[] array in the range
 114      [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs).  */
 115   descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
 116
 117   /* Lay out the register cache.
 118
 119      NOTE: cagney/2002-05-22: Only register_type() is used when
 120      constructing the register cache.  It is assumed that the
 121      register's raw size, virtual size and type length are all the
 122      same.  */
 123
 124   {
 125     long offset = 0;
 126     descr->sizeof_register
 127       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 128     descr->register_offset
 129       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 130     for (i = 0; i < descr->nr_cooked_registers; i++)
 131       {
 132         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 133         descr->register_offset[i] = offset;
 134         offset += descr->sizeof_register[i];
 135         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 136       }
 137     /* Set the real size of the register cache buffer.  */
 138     descr->sizeof_cooked_registers = offset;
 139   }
 140
 141   /* FIXME: cagney/2002-05-22: Should only need to allocate space for
 142      the raw registers.  Unfortunately some code still accesses the
 143      register array directly using the global registers[].  Until that
 144      code has been purged, play safe and over allocating the register
 145      buffer.  Ulgh!  */
 146   descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
 147
 148   return descr;
 149 }
 150
 151 static struct regcache_descr *
 152 regcache_descr (struct gdbarch *gdbarch)
 153 {
 154   return gdbarch_data (gdbarch, regcache_descr_handle);
 155 }
 156
 157 /* Utility functions returning useful register attributes stored in
 158    the regcache descr.  */
 159
 160 struct type *
 161 register_type (struct gdbarch *gdbarch, int regnum)
 162 {
 163   struct regcache_descr *descr = regcache_descr (gdbarch);
 164   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 165   return descr->register_type[regnum];
 166 }
 167
 168 /* Utility functions returning useful register attributes stored in
 169    the regcache descr.  */
 170
 171 int
 172 register_size (struct gdbarch *gdbarch, int regnum)
 173 {
 174   struct regcache_descr *descr = regcache_descr (gdbarch);
 175   int size;
 176   gdb_assert (regnum >= 0
 177               && regnum < (gdbarch_num_regs (current_gdbarch)
 178                            + gdbarch_num_pseudo_regs (current_gdbarch)));
 179   size = descr->sizeof_register[regnum];
 180   return size;
 181 }
 182
 183 /* The register cache for storing raw register values.  */
 184
 185 struct regcache
 186 {
 187   struct regcache_descr *descr;
 188   /* The register buffers.  A read-only register cache can hold the
 189      full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
 190      register cache can only hold [0 .. gdbarch_num_regs).  */
 191   gdb_byte *registers;
 192   /* Register cache status:
 193      register_valid_p[REG] == 0 if REG value is not in the cache
 194                             > 0 if REG value is in the cache
 195                             < 0 if REG value is permanently unavailable */
 196   signed char *register_valid_p;
 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 struct regcache *
 210 regcache_xmalloc (struct gdbarch *gdbarch)
 211 {
 212   struct regcache_descr *descr;
 213   struct regcache *regcache;
 214   gdb_assert (gdbarch != NULL);
 215   descr = regcache_descr (gdbarch);
 216   regcache = XMALLOC (struct regcache);
 217   regcache->descr = descr;
 218   regcache->registers
 219     = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
 220   regcache->register_valid_p
 221     = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
 222   regcache->readonly_p = 1;
 223   regcache->ptid = minus_one_ptid;
 224   return regcache;
 225 }
 226
 227 void
 228 regcache_xfree (struct regcache *regcache)
 229 {
 230   if (regcache == NULL)
 231     return;
 232   xfree (regcache->registers);
 233   xfree (regcache->register_valid_p);
 234   xfree (regcache);
 235 }
 236
 237 static void
 238 do_regcache_xfree (void *data)
 239 {
 240   regcache_xfree (data);
 241 }
 242
 243 struct cleanup *
 244 make_cleanup_regcache_xfree (struct regcache *regcache)
 245 {
 246   return make_cleanup (do_regcache_xfree, regcache);
 247 }
 248
 249 /* Return REGCACHE's architecture.  */
 250
 251 struct gdbarch *
 252 get_regcache_arch (const struct regcache *regcache)
 253 {
 254   return regcache->descr->gdbarch;
 255 }
 256
 257 /* Return  a pointer to register REGNUM's buffer cache.  */
 258
 259 static gdb_byte *
 260 register_buffer (const struct regcache *regcache, int regnum)
 261 {
 262   return regcache->registers + regcache->descr->register_offset[regnum];
 263 }
 264
 265 void
 266 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 267                void *src)
 268 {
 269   struct gdbarch *gdbarch = dst->descr->gdbarch;
 270   gdb_byte buf[MAX_REGISTER_SIZE];
 271   int regnum;
 272   /* The DST should be `read-only', if it wasn't then the save would
 273      end up trying to write the register values back out to the
 274      target.  */
 275   gdb_assert (dst->readonly_p);
 276   /* Clear the dest.  */
 277   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 278   memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
 279   /* Copy over any registers (identified by their membership in the
 280      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
 281      gdbarch_num_pseudo_regs) range is checked since some architectures need
 282      to save/restore `cooked' registers that live in memory.  */
 283   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 284     {
 285       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 286         {
 287           int valid = cooked_read (src, regnum, buf);
 288           if (valid)
 289             {
 290               memcpy (register_buffer (dst, regnum), buf,
 291                       register_size (gdbarch, regnum));
 292               dst->register_valid_p[regnum] = 1;
 293             }
 294         }
 295     }
 296 }
 297
 298 void
 299 regcache_restore (struct regcache *dst,
 300                   regcache_cooked_read_ftype *cooked_read,
 301                   void *cooked_read_context)
 302 {
 303   struct gdbarch *gdbarch = dst->descr->gdbarch;
 304   gdb_byte buf[MAX_REGISTER_SIZE];
 305   int regnum;
 306   /* The dst had better not be read-only.  If it is, the `restore'
 307      doesn't make much sense.  */
 308   gdb_assert (!dst->readonly_p);
 309   /* Copy over any registers, being careful to only restore those that
 310      were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
 311      + gdbarch_num_pseudo_regs) range is checked since some architectures need
 312      to save/restore `cooked' registers that live in memory.  */
 313   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 314     {
 315       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 316         {
 317           int valid = cooked_read (cooked_read_context, regnum, buf);
 318           if (valid)
 319             regcache_cooked_write (dst, regnum, buf);
 320         }
 321     }
 322 }
 323
 324 static int
 325 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 326 {
 327   struct regcache *regcache = src;
 328   if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
 329     /* Don't even think about fetching a register from a read-only
 330        cache when the register isn't yet valid.  There isn't a target
 331        from which the register value can be fetched.  */
 332     return 0;
 333   regcache_cooked_read (regcache, regnum, buf);
 334   return 1;
 335 }
 336
 337
 338 void
 339 regcache_cpy (struct regcache *dst, struct regcache *src)
 340 {
 341   int i;
 342   gdb_byte *buf;
 343   gdb_assert (src != NULL && dst != NULL);
 344   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 345   gdb_assert (src != dst);
 346   gdb_assert (src->readonly_p || dst->readonly_p);
 347   if (!src->readonly_p)
 348     regcache_save (dst, do_cooked_read, src);
 349   else if (!dst->readonly_p)
 350     regcache_restore (dst, do_cooked_read, src);
 351   else
 352     regcache_cpy_no_passthrough (dst, src);
 353 }
 354
 355 void
 356 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 357 {
 358   int i;
 359   gdb_assert (src != NULL && dst != NULL);
 360   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 361   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 362      move of data into the current regcache.  Doing this would be
 363      silly - it would mean that valid_p would be completely invalid.  */
 364   gdb_assert (dst->readonly_p);
 365   memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
 366   memcpy (dst->register_valid_p, src->register_valid_p,
 367           dst->descr->sizeof_raw_register_valid_p);
 368 }
 369
 370 struct regcache *
 371 regcache_dup (struct regcache *src)
 372 {
 373   struct regcache *newbuf;
 374   newbuf = regcache_xmalloc (src->descr->gdbarch);
 375   regcache_cpy (newbuf, src);
 376   return newbuf;
 377 }
 378
 379 struct regcache *
 380 regcache_dup_no_passthrough (struct regcache *src)
 381 {
 382   struct regcache *newbuf;
 383   newbuf = regcache_xmalloc (src->descr->gdbarch);
 384   regcache_cpy_no_passthrough (newbuf, src);
 385   return newbuf;
 386 }
 387
 388 int
 389 regcache_valid_p (const struct regcache *regcache, int regnum)
 390 {
 391   gdb_assert (regcache != NULL);
 392   gdb_assert (regnum >= 0);
 393   if (regcache->readonly_p)
 394     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 395   else
 396     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 397
 398   return regcache->register_valid_p[regnum];
 399 }
 400
 401 void
 402 regcache_invalidate (struct regcache *regcache, int regnum)
 403 {
 404   gdb_assert (regcache != NULL);
 405   gdb_assert (regnum >= 0);
 406   gdb_assert (!regcache->readonly_p);
 407   gdb_assert (regnum < regcache->descr->nr_raw_registers);
 408   regcache->register_valid_p[regnum] = 0;
 409 }
 410
 411
 412 /* Global structure containing the current regcache.  */
 413 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
 414    deprecated_register_valid[] currently point into this structure.  */
 415 static struct regcache *current_regcache;
 416
 417 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 418    recording if the register values have been changed (eg. by the
 419    user).  Therefore all registers must be written back to the
 420    target when appropriate.  */
 421
 422 struct regcache *get_thread_regcache (ptid_t ptid)
 423 {
 424   /* NOTE: uweigand/2007-05-05:  We need to detect the thread's
 425      current architecture at this point.  */
 426   struct gdbarch *thread_gdbarch = current_gdbarch;
 427
 428   if (current_regcache && ptid_equal (current_regcache->ptid, ptid)
 429       && get_regcache_arch (current_regcache) == thread_gdbarch)
 430     return current_regcache;
 431
 432   if (current_regcache)
 433     regcache_xfree (current_regcache);
 434
 435   current_regcache = regcache_xmalloc (thread_gdbarch);
 436   current_regcache->readonly_p = 0;
 437   current_regcache->ptid = ptid;
 438
 439   return current_regcache;
 440 }
 441
 442 struct regcache *get_current_regcache (void)
 443 {
 444   return get_thread_regcache (inferior_ptid);
 445 }
 446
 447
 448 /* Observer for the target_changed event.  */
 449
 450 void
 451 regcache_observer_target_changed (struct target_ops *target)
 452 {
 453   registers_changed ();
 454 }
 455
 456 /* Low level examining and depositing of registers.
 457
 458    The caller is responsible for making sure that the inferior is
 459    stopped before calling the fetching routines, or it will get
 460    garbage.  (a change from GDB version 3, in which the caller got the
 461    value from the last stop).  */
 462
 463 /* REGISTERS_CHANGED ()
 464
 465    Indicate that registers may have changed, so invalidate the cache.  */
 466
 467 void
 468 registers_changed (void)
 469 {
 470   int i;
 471
 472   regcache_xfree (current_regcache);
 473   current_regcache = NULL;
 474
 475   /* Force cleanup of any alloca areas if using C alloca instead of
 476      a builtin alloca.  This particular call is used to clean up
 477      areas allocated by low level target code which may build up
 478      during lengthy interactions between gdb and the target before
 479      gdb gives control to the user (ie watchpoints).  */
 480   alloca (0);
 481 }
 482
 483
 484 void
 485 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 486 {
 487   gdb_assert (regcache != NULL && buf != NULL);
 488   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 489   /* Make certain that the register cache is up-to-date with respect
 490      to the current thread.  This switching shouldn't be necessary
 491      only there is still only one target side register cache.  Sigh!
 492      On the bright side, at least there is a regcache object.  */
 493   if (!regcache->readonly_p)
 494     {
 495       if (!regcache_valid_p (regcache, regnum))
 496         {
 497           struct cleanup *old_chain = save_inferior_ptid ();
 498           inferior_ptid = regcache->ptid;
 499           target_fetch_registers (regcache, regnum);
 500           do_cleanups (old_chain);
 501         }
 502 #if 0
 503       /* FIXME: cagney/2004-08-07: At present a number of targets
 504          forget (or didn't know that they needed) to set this leading to
 505          panics.  Also is the problem that targets need to indicate
 506          that a register is in one of the possible states: valid,
 507          undefined, unknown.  The last of which isn't yet
 508          possible.  */
 509       gdb_assert (regcache_valid_p (regcache, regnum));
 510 #endif
 511     }
 512   /* Copy the value directly into the register cache.  */
 513   memcpy (buf, register_buffer (regcache, regnum),
 514           regcache->descr->sizeof_register[regnum]);
 515 }
 516
 517 void
 518 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 519 {
 520   gdb_byte *buf;
 521   gdb_assert (regcache != NULL);
 522   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 523   buf = alloca (regcache->descr->sizeof_register[regnum]);
 524   regcache_raw_read (regcache, regnum, buf);
 525   (*val) = extract_signed_integer (buf,
 526                                    regcache->descr->sizeof_register[regnum]);
 527 }
 528
 529 void
 530 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 531                             ULONGEST *val)
 532 {
 533   gdb_byte *buf;
 534   gdb_assert (regcache != NULL);
 535   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 536   buf = alloca (regcache->descr->sizeof_register[regnum]);
 537   regcache_raw_read (regcache, regnum, buf);
 538   (*val) = extract_unsigned_integer (buf,
 539                                      regcache->descr->sizeof_register[regnum]);
 540 }
 541
 542 void
 543 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 544 {
 545   void *buf;
 546   gdb_assert (regcache != NULL);
 547   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 548   buf = alloca (regcache->descr->sizeof_register[regnum]);
 549   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 550   regcache_raw_write (regcache, regnum, buf);
 551 }
 552
 553 void
 554 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 555                              ULONGEST val)
 556 {
 557   void *buf;
 558   gdb_assert (regcache != NULL);
 559   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 560   buf = alloca (regcache->descr->sizeof_register[regnum]);
 561   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 562   regcache_raw_write (regcache, regnum, buf);
 563 }
 564
 565 void
 566 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 567 {
 568   gdb_assert (regnum >= 0);
 569   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 570   if (regnum < regcache->descr->nr_raw_registers)
 571     regcache_raw_read (regcache, regnum, buf);
 572   else if (regcache->readonly_p
 573            && regnum < regcache->descr->nr_cooked_registers
 574            && regcache->register_valid_p[regnum])
 575     /* Read-only register cache, perhaps the cooked value was cached?  */
 576     memcpy (buf, register_buffer (regcache, regnum),
 577             regcache->descr->sizeof_register[regnum]);
 578   else
 579     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 580                                   regnum, buf);
 581 }
 582
 583 void
 584 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 585                              LONGEST *val)
 586 {
 587   gdb_byte *buf;
 588   gdb_assert (regcache != NULL);
 589   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 590   buf = alloca (regcache->descr->sizeof_register[regnum]);
 591   regcache_cooked_read (regcache, regnum, buf);
 592   (*val) = extract_signed_integer (buf,
 593                                    regcache->descr->sizeof_register[regnum]);
 594 }
 595
 596 void
 597 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 598                                ULONGEST *val)
 599 {
 600   gdb_byte *buf;
 601   gdb_assert (regcache != NULL);
 602   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 603   buf = alloca (regcache->descr->sizeof_register[regnum]);
 604   regcache_cooked_read (regcache, regnum, buf);
 605   (*val) = extract_unsigned_integer (buf,
 606                                      regcache->descr->sizeof_register[regnum]);
 607 }
 608
 609 void
 610 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 611                               LONGEST val)
 612 {
 613   void *buf;
 614   gdb_assert (regcache != NULL);
 615   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 616   buf = alloca (regcache->descr->sizeof_register[regnum]);
 617   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 618   regcache_cooked_write (regcache, regnum, buf);
 619 }
 620
 621 void
 622 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 623                                 ULONGEST val)
 624 {
 625   void *buf;
 626   gdb_assert (regcache != NULL);
 627   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 628   buf = alloca (regcache->descr->sizeof_register[regnum]);
 629   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 630   regcache_cooked_write (regcache, regnum, buf);
 631 }
 632
 633 void
 634 regcache_raw_write (struct regcache *regcache, int regnum,
 635                     const gdb_byte *buf)
 636 {
 637   struct cleanup *old_chain;
 638
 639   gdb_assert (regcache != NULL && buf != NULL);
 640   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 641   gdb_assert (!regcache->readonly_p);
 642
 643   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 644      change the registers array if something writes to this register.  */
 645   if (gdbarch_cannot_store_register (current_gdbarch, regnum))
 646     return;
 647
 648   /* If we have a valid copy of the register, and new value == old
 649      value, then don't bother doing the actual store. */
 650   if (regcache_valid_p (regcache, regnum)
 651       && (memcmp (register_buffer (regcache, regnum), buf,
 652                   regcache->descr->sizeof_register[regnum]) == 0))
 653     return;
 654
 655   old_chain = save_inferior_ptid ();
 656   inferior_ptid = regcache->ptid;
 657
 658   target_prepare_to_store (regcache);
 659   memcpy (register_buffer (regcache, regnum), buf,
 660           regcache->descr->sizeof_register[regnum]);
 661   regcache->register_valid_p[regnum] = 1;
 662   target_store_registers (regcache, regnum);
 663
 664   do_cleanups (old_chain);
 665 }
 666
 667 void
 668 regcache_cooked_write (struct regcache *regcache, int regnum,
 669                        const gdb_byte *buf)
 670 {
 671   gdb_assert (regnum >= 0);
 672   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 673   if (regnum < regcache->descr->nr_raw_registers)
 674     regcache_raw_write (regcache, regnum, buf);
 675   else
 676     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 677                                    regnum, buf);
 678 }
 679
 680 /* Perform a partial register transfer using a read, modify, write
 681    operation.  */
 682
 683 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 684                                     void *buf);
 685 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 686                                      const void *buf);
 687
 688 static void
 689 regcache_xfer_part (struct regcache *regcache, int regnum,
 690                     int offset, int len, void *in, const void *out,
 691                     void (*read) (struct regcache *regcache, int regnum,
 692                                   gdb_byte *buf),
 693                     void (*write) (struct regcache *regcache, int regnum,
 694                                    const gdb_byte *buf))
 695 {
 696   struct regcache_descr *descr = regcache->descr;
 697   gdb_byte reg[MAX_REGISTER_SIZE];
 698   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 699   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 700   /* Something to do?  */
 701   if (offset + len == 0)
 702     return;
 703   /* Read (when needed) ... */
 704   if (in != NULL
 705       || offset > 0
 706       || offset + len < descr->sizeof_register[regnum])
 707     {
 708       gdb_assert (read != NULL);
 709       read (regcache, regnum, reg);
 710     }
 711   /* ... modify ... */
 712   if (in != NULL)
 713     memcpy (in, reg + offset, len);
 714   if (out != NULL)
 715     memcpy (reg + offset, out, len);
 716   /* ... write (when needed).  */
 717   if (out != NULL)
 718     {
 719       gdb_assert (write != NULL);
 720       write (regcache, regnum, reg);
 721     }
 722 }
 723
 724 void
 725 regcache_raw_read_part (struct regcache *regcache, int regnum,
 726                         int offset, int len, gdb_byte *buf)
 727 {
 728   struct regcache_descr *descr = regcache->descr;
 729   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 730   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 731                       regcache_raw_read, regcache_raw_write);
 732 }
 733
 734 void
 735 regcache_raw_write_part (struct regcache *regcache, int regnum,
 736                          int offset, int len, const gdb_byte *buf)
 737 {
 738   struct regcache_descr *descr = regcache->descr;
 739   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 740   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 741                       regcache_raw_read, regcache_raw_write);
 742 }
 743
 744 void
 745 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 746                            int offset, int len, gdb_byte *buf)
 747 {
 748   struct regcache_descr *descr = regcache->descr;
 749   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 750   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 751                       regcache_cooked_read, regcache_cooked_write);
 752 }
 753
 754 void
 755 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 756                             int offset, int len, const gdb_byte *buf)
 757 {
 758   struct regcache_descr *descr = regcache->descr;
 759   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 760   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 761                       regcache_cooked_read, regcache_cooked_write);
 762 }
 763
 764 /* Hack to keep code that view the register buffer as raw bytes
 765    working.  */
 766
 767 int
 768 register_offset_hack (struct gdbarch *gdbarch, int regnum)
 769 {
 770   struct regcache_descr *descr = regcache_descr (gdbarch);
 771   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 772   return descr->register_offset[regnum];
 773 }
 774
 775
 776 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 777
 778 void
 779 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 780 {
 781   void *regbuf;
 782   size_t size;
 783
 784   gdb_assert (regcache != NULL);
 785   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 786   gdb_assert (!regcache->readonly_p);
 787
 788   regbuf = register_buffer (regcache, regnum);
 789   size = regcache->descr->sizeof_register[regnum];
 790
 791   if (buf)
 792     memcpy (regbuf, buf, size);
 793   else
 794     memset (regbuf, 0, size);
 795
 796   /* Mark the register as cached.  */
 797   regcache->register_valid_p[regnum] = 1;
 798 }
 799
 800 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 801
 802 void
 803 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 804 {
 805   const void *regbuf;
 806   size_t size;
 807
 808   gdb_assert (regcache != NULL && buf != NULL);
 809   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 810
 811   regbuf = register_buffer (regcache, regnum);
 812   size = regcache->descr->sizeof_register[regnum];
 813   memcpy (buf, regbuf, size);
 814 }
 815
 816
 817 /* read_pc, write_pc, etc.  Special handling for register PC.  */
 818
 819 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
 820    read_sp(), will eventually be replaced by per-frame methods.
 821    Instead of relying on the global INFERIOR_PTID, they will use the
 822    contextual information provided by the FRAME.  These functions do
 823    not belong in the register cache.  */
 824
 825 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
 826    write_pc_pid() and write_pc(), all need to be replaced by something
 827    that does not rely on global state.  But what?  */
 828
 829 CORE_ADDR
 830 read_pc_pid (ptid_t ptid)
 831 {
 832   struct regcache *regcache = get_thread_regcache (ptid);
 833   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 834
 835   CORE_ADDR pc_val;
 836
 837   if (gdbarch_read_pc_p (gdbarch))
 838     pc_val = gdbarch_read_pc (gdbarch, regcache);
 839   /* Else use per-frame method on get_current_frame.  */
 840   else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
 841     {
 842       ULONGEST raw_val;
 843       regcache_cooked_read_unsigned (regcache,
 844                                      gdbarch_pc_regnum (current_gdbarch),
 845                                      &raw_val);
 846       pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
 847     }
 848   else
 849     internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
 850
 851   return pc_val;
 852 }
 853
 854 CORE_ADDR
 855 read_pc (void)
 856 {
 857   return read_pc_pid (inferior_ptid);
 858 }
 859
 860 void
 861 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
 862 {
 863   struct regcache *regcache = get_thread_regcache (ptid);
 864   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 865
 866   if (gdbarch_write_pc_p (gdbarch))
 867     gdbarch_write_pc (gdbarch, regcache, pc);
 868   else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
 869     regcache_cooked_write_unsigned (regcache,
 870                                     gdbarch_pc_regnum (current_gdbarch), pc);
 871   else
 872     internal_error (__FILE__, __LINE__,
 873                     _("write_pc_pid: Unable to update PC"));
 874 }
 875
 876 void
 877 write_pc (CORE_ADDR pc)
 878 {
 879   write_pc_pid (pc, inferior_ptid);
 880 }
 881
 882
 883 static void
 884 reg_flush_command (char *command, int from_tty)
 885 {
 886   /* Force-flush the register cache.  */
 887   registers_changed ();
 888   if (from_tty)
 889     printf_filtered (_("Register cache flushed.\n"));
 890 }
 891
 892 static void
 893 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
 894                    const unsigned char *buf, long len)
 895 {
 896   int i;
 897   switch (endian)
 898     {
 899     case BFD_ENDIAN_BIG:
 900       for (i = 0; i < len; i++)
 901         fprintf_unfiltered (file, "%02x", buf[i]);
 902       break;
 903     case BFD_ENDIAN_LITTLE:
 904       for (i = len - 1; i >= 0; i--)
 905         fprintf_unfiltered (file, "%02x", buf[i]);
 906       break;
 907     default:
 908       internal_error (__FILE__, __LINE__, _("Bad switch"));
 909     }
 910 }
 911
 912 enum regcache_dump_what
 913 {
 914   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
 915 };
 916
 917 static void
 918 regcache_dump (struct regcache *regcache, struct ui_file *file,
 919                enum regcache_dump_what what_to_dump)
 920 {
 921   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
 922   struct gdbarch *gdbarch = regcache->descr->gdbarch;
 923   int regnum;
 924   int footnote_nr = 0;
 925   int footnote_register_size = 0;
 926   int footnote_register_offset = 0;
 927   int footnote_register_type_name_null = 0;
 928   long register_offset = 0;
 929   unsigned char buf[MAX_REGISTER_SIZE];
 930
 931 #if 0
 932   fprintf_unfiltered (file, "nr_raw_registers %d\n",
 933                       regcache->descr->nr_raw_registers);
 934   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
 935                       regcache->descr->nr_cooked_registers);
 936   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
 937                       regcache->descr->sizeof_raw_registers);
 938   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
 939                       regcache->descr->sizeof_raw_register_valid_p);
 940   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
 941                       gdbarch_num_regs (current_gdbarch));
 942   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
 943                       gdbarch_num_pseudo_regs (current_gdbarch));
 944 #endif
 945
 946   gdb_assert (regcache->descr->nr_cooked_registers
 947               == (gdbarch_num_regs (current_gdbarch)
 948                   + gdbarch_num_pseudo_regs (current_gdbarch)));
 949
 950   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
 951     {
 952       /* Name.  */
 953       if (regnum < 0)
 954         fprintf_unfiltered (file, " %-10s", "Name");
 955       else
 956         {
 957           const char *p = gdbarch_register_name (current_gdbarch, regnum);
 958           if (p == NULL)
 959             p = "";
 960           else if (p[0] == '\0')
 961             p = "''";
 962           fprintf_unfiltered (file, " %-10s", p);
 963         }
 964
 965       /* Number.  */
 966       if (regnum < 0)
 967         fprintf_unfiltered (file, " %4s", "Nr");
 968       else
 969         fprintf_unfiltered (file, " %4d", regnum);
 970
 971       /* Relative number.  */
 972       if (regnum < 0)
 973         fprintf_unfiltered (file, " %4s", "Rel");
 974       else if (regnum < gdbarch_num_regs (current_gdbarch))
 975         fprintf_unfiltered (file, " %4d", regnum);
 976       else
 977         fprintf_unfiltered (file, " %4d",
 978                             (regnum - gdbarch_num_regs (current_gdbarch)));
 979
 980       /* Offset.  */
 981       if (regnum < 0)
 982         fprintf_unfiltered (file, " %6s  ", "Offset");
 983       else
 984         {
 985           fprintf_unfiltered (file, " %6ld",
 986                               regcache->descr->register_offset[regnum]);
 987           if (register_offset != regcache->descr->register_offset[regnum]
 988               || (regnum > 0
 989                   && (regcache->descr->register_offset[regnum]
 990                       != (regcache->descr->register_offset[regnum - 1]
 991                           + regcache->descr->sizeof_register[regnum - 1])))
 992               )
 993             {
 994               if (!footnote_register_offset)
 995                 footnote_register_offset = ++footnote_nr;
 996               fprintf_unfiltered (file, "*%d", footnote_register_offset);
 997             }
 998           else
 999             fprintf_unfiltered (file, "  ");
1000           register_offset = (regcache->descr->register_offset[regnum]
1001                              + regcache->descr->sizeof_register[regnum]);
1002         }
1003
1004       /* Size.  */
1005       if (regnum < 0)
1006         fprintf_unfiltered (file, " %5s ", "Size");
1007       else
1008         fprintf_unfiltered (file, " %5ld",
1009                             regcache->descr->sizeof_register[regnum]);
1010
1011       /* Type.  */
1012       {
1013         const char *t;
1014         if (regnum < 0)
1015           t = "Type";
1016         else
1017           {
1018             static const char blt[] = "builtin_type";
1019             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1020             if (t == NULL)
1021               {
1022                 char *n;
1023                 if (!footnote_register_type_name_null)
1024                   footnote_register_type_name_null = ++footnote_nr;
1025                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1026                 make_cleanup (xfree, n);
1027                 t = n;
1028               }
1029             /* Chop a leading builtin_type.  */
1030             if (strncmp (t, blt, strlen (blt)) == 0)
1031               t += strlen (blt);
1032           }
1033         fprintf_unfiltered (file, " %-15s", t);
1034       }
1035
1036       /* Leading space always present.  */
1037       fprintf_unfiltered (file, " ");
1038
1039       /* Value, raw.  */
1040       if (what_to_dump == regcache_dump_raw)
1041         {
1042           if (regnum < 0)
1043             fprintf_unfiltered (file, "Raw value");
1044           else if (regnum >= regcache->descr->nr_raw_registers)
1045             fprintf_unfiltered (file, "<cooked>");
1046           else if (!regcache_valid_p (regcache, regnum))
1047             fprintf_unfiltered (file, "<invalid>");
1048           else
1049             {
1050               regcache_raw_read (regcache, regnum, buf);
1051               fprintf_unfiltered (file, "0x");
1052               dump_endian_bytes (file,
1053                                  gdbarch_byte_order (current_gdbarch), buf,
1054                                  regcache->descr->sizeof_register[regnum]);
1055             }
1056         }
1057
1058       /* Value, cooked.  */
1059       if (what_to_dump == regcache_dump_cooked)
1060         {
1061           if (regnum < 0)
1062             fprintf_unfiltered (file, "Cooked value");
1063           else
1064             {
1065               regcache_cooked_read (regcache, regnum, buf);
1066               fprintf_unfiltered (file, "0x");
1067               dump_endian_bytes (file,
1068                                  gdbarch_byte_order (current_gdbarch), buf,
1069                                  regcache->descr->sizeof_register[regnum]);
1070             }
1071         }
1072
1073       /* Group members.  */
1074       if (what_to_dump == regcache_dump_groups)
1075         {
1076           if (regnum < 0)
1077             fprintf_unfiltered (file, "Groups");
1078           else
1079             {
1080               const char *sep = "";
1081               struct reggroup *group;
1082               for (group = reggroup_next (gdbarch, NULL);
1083                    group != NULL;
1084                    group = reggroup_next (gdbarch, group))
1085                 {
1086                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1087                     {
1088                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1089                       sep = ",";
1090                     }
1091                 }
1092             }
1093         }
1094
1095       fprintf_unfiltered (file, "\n");
1096     }
1097
1098   if (footnote_register_size)
1099     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1100                         footnote_register_size);
1101   if (footnote_register_offset)
1102     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1103                         footnote_register_offset);
1104   if (footnote_register_type_name_null)
1105     fprintf_unfiltered (file,
1106                         "*%d: Register type's name NULL.\n",
1107                         footnote_register_type_name_null);
1108   do_cleanups (cleanups);
1109 }
1110
1111 static void
1112 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1113 {
1114   if (args == NULL)
1115     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1116   else
1117     {
1118       struct ui_file *file = gdb_fopen (args, "w");
1119       if (file == NULL)
1120         perror_with_name (_("maintenance print architecture"));
1121       regcache_dump (get_current_regcache (), file, what_to_dump);
1122       ui_file_delete (file);
1123     }
1124 }
1125
1126 static void
1127 maintenance_print_registers (char *args, int from_tty)
1128 {
1129   regcache_print (args, regcache_dump_none);
1130 }
1131
1132 static void
1133 maintenance_print_raw_registers (char *args, int from_tty)
1134 {
1135   regcache_print (args, regcache_dump_raw);
1136 }
1137
1138 static void
1139 maintenance_print_cooked_registers (char *args, int from_tty)
1140 {
1141   regcache_print (args, regcache_dump_cooked);
1142 }
1143
1144 static void
1145 maintenance_print_register_groups (char *args, int from_tty)
1146 {
1147   regcache_print (args, regcache_dump_groups);
1148 }
1149
1150 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1151
1152 void
1153 _initialize_regcache (void)
1154 {
1155   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1156
1157   observer_attach_target_changed (regcache_observer_target_changed);
1158
1159   add_com ("flushregs", class_maintenance, reg_flush_command,
1160            _("Force gdb to flush its register cache (maintainer command)"));
1161
1162   add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1163 Print the internal register configuration.\n\
1164 Takes an optional file parameter."), &maintenanceprintlist);
1165   add_cmd ("raw-registers", class_maintenance,
1166            maintenance_print_raw_registers, _("\
1167 Print the internal register configuration including raw values.\n\
1168 Takes an optional file parameter."), &maintenanceprintlist);
1169   add_cmd ("cooked-registers", class_maintenance,
1170            maintenance_print_cooked_registers, _("\
1171 Print the internal register configuration including cooked values.\n\
1172 Takes an optional file parameter."), &maintenanceprintlist);
1173   add_cmd ("register-groups", class_maintenance,
1174            maintenance_print_register_groups, _("\
1175 Print the internal register configuration including each register's group.\n\
1176 Takes an optional file parameter."),
1177            &maintenanceprintlist);
1178
1179 }