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, 2008 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 (gdbarch)
  96                                + gdbarch_num_pseudo_regs (gdbarch);
  97   descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
  98                                           + gdbarch_num_pseudo_regs
  99                                               (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 (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 (gdbarch)
 178                            + gdbarch_num_pseudo_regs (gdbarch)));
 179   size = descr->sizeof_register[regnum];
 180   return size;
 181 }
 182
 183 /* The register cache for storing raw register values.  */
 184
 185 struct regcache
 186 {
 187   struct regcache_descr *descr;
 188   /* 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   /* Need to forget about any frames we have cached, too. */
 476   reinit_frame_cache ();
 477
 478   /* Force cleanup of any alloca areas if using C alloca instead of
 479      a builtin alloca.  This particular call is used to clean up
 480      areas allocated by low level target code which may build up
 481      during lengthy interactions between gdb and the target before
 482      gdb gives control to the user (ie watchpoints).  */
 483   alloca (0);
 484 }
 485
 486
 487 void
 488 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 489 {
 490   gdb_assert (regcache != NULL && buf != NULL);
 491   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 492   /* Make certain that the register cache is up-to-date with respect
 493      to the current thread.  This switching shouldn't be necessary
 494      only there is still only one target side register cache.  Sigh!
 495      On the bright side, at least there is a regcache object.  */
 496   if (!regcache->readonly_p)
 497     {
 498       if (!regcache_valid_p (regcache, regnum))
 499         {
 500           struct cleanup *old_chain = save_inferior_ptid ();
 501           inferior_ptid = regcache->ptid;
 502           target_fetch_registers (regcache, regnum);
 503           do_cleanups (old_chain);
 504         }
 505 #if 0
 506       /* FIXME: cagney/2004-08-07: At present a number of targets
 507          forget (or didn't know that they needed) to set this leading to
 508          panics.  Also is the problem that targets need to indicate
 509          that a register is in one of the possible states: valid,
 510          undefined, unknown.  The last of which isn't yet
 511          possible.  */
 512       gdb_assert (regcache_valid_p (regcache, regnum));
 513 #endif
 514     }
 515   /* Copy the value directly into the register cache.  */
 516   memcpy (buf, register_buffer (regcache, regnum),
 517           regcache->descr->sizeof_register[regnum]);
 518 }
 519
 520 void
 521 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 522 {
 523   gdb_byte *buf;
 524   gdb_assert (regcache != NULL);
 525   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 526   buf = alloca (regcache->descr->sizeof_register[regnum]);
 527   regcache_raw_read (regcache, regnum, buf);
 528   (*val) = extract_signed_integer (buf,
 529                                    regcache->descr->sizeof_register[regnum]);
 530 }
 531
 532 void
 533 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 534                             ULONGEST *val)
 535 {
 536   gdb_byte *buf;
 537   gdb_assert (regcache != NULL);
 538   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 539   buf = alloca (regcache->descr->sizeof_register[regnum]);
 540   regcache_raw_read (regcache, regnum, buf);
 541   (*val) = extract_unsigned_integer (buf,
 542                                      regcache->descr->sizeof_register[regnum]);
 543 }
 544
 545 void
 546 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 547 {
 548   void *buf;
 549   gdb_assert (regcache != NULL);
 550   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 551   buf = alloca (regcache->descr->sizeof_register[regnum]);
 552   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 553   regcache_raw_write (regcache, regnum, buf);
 554 }
 555
 556 void
 557 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 558                              ULONGEST val)
 559 {
 560   void *buf;
 561   gdb_assert (regcache != NULL);
 562   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 563   buf = alloca (regcache->descr->sizeof_register[regnum]);
 564   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 565   regcache_raw_write (regcache, regnum, buf);
 566 }
 567
 568 void
 569 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 570 {
 571   gdb_assert (regnum >= 0);
 572   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 573   if (regnum < regcache->descr->nr_raw_registers)
 574     regcache_raw_read (regcache, regnum, buf);
 575   else if (regcache->readonly_p
 576            && regnum < regcache->descr->nr_cooked_registers
 577            && regcache->register_valid_p[regnum])
 578     /* Read-only register cache, perhaps the cooked value was cached?  */
 579     memcpy (buf, register_buffer (regcache, regnum),
 580             regcache->descr->sizeof_register[regnum]);
 581   else
 582     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 583                                   regnum, buf);
 584 }
 585
 586 void
 587 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 588                              LONGEST *val)
 589 {
 590   gdb_byte *buf;
 591   gdb_assert (regcache != NULL);
 592   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 593   buf = alloca (regcache->descr->sizeof_register[regnum]);
 594   regcache_cooked_read (regcache, regnum, buf);
 595   (*val) = extract_signed_integer (buf,
 596                                    regcache->descr->sizeof_register[regnum]);
 597 }
 598
 599 void
 600 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 601                                ULONGEST *val)
 602 {
 603   gdb_byte *buf;
 604   gdb_assert (regcache != NULL);
 605   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 606   buf = alloca (regcache->descr->sizeof_register[regnum]);
 607   regcache_cooked_read (regcache, regnum, buf);
 608   (*val) = extract_unsigned_integer (buf,
 609                                      regcache->descr->sizeof_register[regnum]);
 610 }
 611
 612 void
 613 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 614                               LONGEST val)
 615 {
 616   void *buf;
 617   gdb_assert (regcache != NULL);
 618   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 619   buf = alloca (regcache->descr->sizeof_register[regnum]);
 620   store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
 621   regcache_cooked_write (regcache, regnum, buf);
 622 }
 623
 624 void
 625 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 626                                 ULONGEST val)
 627 {
 628   void *buf;
 629   gdb_assert (regcache != NULL);
 630   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 631   buf = alloca (regcache->descr->sizeof_register[regnum]);
 632   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
 633   regcache_cooked_write (regcache, regnum, buf);
 634 }
 635
 636 void
 637 regcache_raw_write (struct regcache *regcache, int regnum,
 638                     const gdb_byte *buf)
 639 {
 640   struct cleanup *old_chain;
 641
 642   gdb_assert (regcache != NULL && buf != NULL);
 643   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 644   gdb_assert (!regcache->readonly_p);
 645
 646   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 647      change the registers array if something writes to this register.  */
 648   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
 649     return;
 650
 651   /* If we have a valid copy of the register, and new value == old
 652      value, then don't bother doing the actual store. */
 653   if (regcache_valid_p (regcache, regnum)
 654       && (memcmp (register_buffer (regcache, regnum), buf,
 655                   regcache->descr->sizeof_register[regnum]) == 0))
 656     return;
 657
 658   old_chain = save_inferior_ptid ();
 659   inferior_ptid = regcache->ptid;
 660
 661   target_prepare_to_store (regcache);
 662   memcpy (register_buffer (regcache, regnum), buf,
 663           regcache->descr->sizeof_register[regnum]);
 664   regcache->register_valid_p[regnum] = 1;
 665   target_store_registers (regcache, regnum);
 666
 667   do_cleanups (old_chain);
 668 }
 669
 670 void
 671 regcache_cooked_write (struct regcache *regcache, int regnum,
 672                        const gdb_byte *buf)
 673 {
 674   gdb_assert (regnum >= 0);
 675   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 676   if (regnum < regcache->descr->nr_raw_registers)
 677     regcache_raw_write (regcache, regnum, buf);
 678   else
 679     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 680                                    regnum, buf);
 681 }
 682
 683 /* Perform a partial register transfer using a read, modify, write
 684    operation.  */
 685
 686 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 687                                     void *buf);
 688 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 689                                      const void *buf);
 690
 691 static void
 692 regcache_xfer_part (struct regcache *regcache, int regnum,
 693                     int offset, int len, void *in, const void *out,
 694                     void (*read) (struct regcache *regcache, int regnum,
 695                                   gdb_byte *buf),
 696                     void (*write) (struct regcache *regcache, int regnum,
 697                                    const gdb_byte *buf))
 698 {
 699   struct regcache_descr *descr = regcache->descr;
 700   gdb_byte reg[MAX_REGISTER_SIZE];
 701   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 702   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 703   /* Something to do?  */
 704   if (offset + len == 0)
 705     return;
 706   /* Read (when needed) ... */
 707   if (in != NULL
 708       || offset > 0
 709       || offset + len < descr->sizeof_register[regnum])
 710     {
 711       gdb_assert (read != NULL);
 712       read (regcache, regnum, reg);
 713     }
 714   /* ... modify ... */
 715   if (in != NULL)
 716     memcpy (in, reg + offset, len);
 717   if (out != NULL)
 718     memcpy (reg + offset, out, len);
 719   /* ... write (when needed).  */
 720   if (out != NULL)
 721     {
 722       gdb_assert (write != NULL);
 723       write (regcache, regnum, reg);
 724     }
 725 }
 726
 727 void
 728 regcache_raw_read_part (struct regcache *regcache, int regnum,
 729                         int offset, int len, gdb_byte *buf)
 730 {
 731   struct regcache_descr *descr = regcache->descr;
 732   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 733   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 734                       regcache_raw_read, regcache_raw_write);
 735 }
 736
 737 void
 738 regcache_raw_write_part (struct regcache *regcache, int regnum,
 739                          int offset, int len, const gdb_byte *buf)
 740 {
 741   struct regcache_descr *descr = regcache->descr;
 742   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 743   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 744                       regcache_raw_read, regcache_raw_write);
 745 }
 746
 747 void
 748 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 749                            int offset, int len, gdb_byte *buf)
 750 {
 751   struct regcache_descr *descr = regcache->descr;
 752   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 753   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 754                       regcache_cooked_read, regcache_cooked_write);
 755 }
 756
 757 void
 758 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 759                             int offset, int len, const gdb_byte *buf)
 760 {
 761   struct regcache_descr *descr = regcache->descr;
 762   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 763   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 764                       regcache_cooked_read, regcache_cooked_write);
 765 }
 766
 767 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 768
 769 void
 770 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 771 {
 772   void *regbuf;
 773   size_t size;
 774
 775   gdb_assert (regcache != NULL);
 776   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 777   gdb_assert (!regcache->readonly_p);
 778
 779   regbuf = register_buffer (regcache, regnum);
 780   size = regcache->descr->sizeof_register[regnum];
 781
 782   if (buf)
 783     memcpy (regbuf, buf, size);
 784   else
 785     memset (regbuf, 0, size);
 786
 787   /* Mark the register as cached.  */
 788   regcache->register_valid_p[regnum] = 1;
 789 }
 790
 791 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 792
 793 void
 794 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 795 {
 796   const void *regbuf;
 797   size_t size;
 798
 799   gdb_assert (regcache != NULL && buf != NULL);
 800   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 801
 802   regbuf = register_buffer (regcache, regnum);
 803   size = regcache->descr->sizeof_register[regnum];
 804   memcpy (buf, regbuf, size);
 805 }
 806
 807
 808 /* read_pc, write_pc, etc.  Special handling for register PC.  */
 809
 810 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
 811    read_sp(), will eventually be replaced by per-frame methods.
 812    Instead of relying on the global INFERIOR_PTID, they will use the
 813    contextual information provided by the FRAME.  These functions do
 814    not belong in the register cache.  */
 815
 816 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
 817    write_pc_pid() and write_pc(), all need to be replaced by something
 818    that does not rely on global state.  But what?  */
 819
 820 CORE_ADDR
 821 read_pc_pid (ptid_t ptid)
 822 {
 823   struct regcache *regcache = get_thread_regcache (ptid);
 824   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 825
 826   CORE_ADDR pc_val;
 827
 828   if (gdbarch_read_pc_p (gdbarch))
 829     pc_val = gdbarch_read_pc (gdbarch, regcache);
 830   /* Else use per-frame method on get_current_frame.  */
 831   else if (gdbarch_pc_regnum (gdbarch) >= 0)
 832     {
 833       ULONGEST raw_val;
 834       regcache_cooked_read_unsigned (regcache,
 835                                      gdbarch_pc_regnum (gdbarch),
 836                                      &raw_val);
 837       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
 838     }
 839   else
 840     internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
 841
 842   return pc_val;
 843 }
 844
 845 CORE_ADDR
 846 read_pc (void)
 847 {
 848   return read_pc_pid (inferior_ptid);
 849 }
 850
 851 void
 852 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
 853 {
 854   struct regcache *regcache = get_thread_regcache (ptid);
 855   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 856
 857   if (gdbarch_write_pc_p (gdbarch))
 858     gdbarch_write_pc (gdbarch, regcache, pc);
 859   else if (gdbarch_pc_regnum (gdbarch) >= 0)
 860     regcache_cooked_write_unsigned (regcache,
 861                                     gdbarch_pc_regnum (gdbarch), pc);
 862   else
 863     internal_error (__FILE__, __LINE__,
 864                     _("write_pc_pid: Unable to update PC"));
 865 }
 866
 867 void
 868 write_pc (CORE_ADDR pc)
 869 {
 870   write_pc_pid (pc, inferior_ptid);
 871 }
 872
 873
 874 static void
 875 reg_flush_command (char *command, int from_tty)
 876 {
 877   /* Force-flush the register cache.  */
 878   registers_changed ();
 879   if (from_tty)
 880     printf_filtered (_("Register cache flushed.\n"));
 881 }
 882
 883 static void
 884 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
 885                    const unsigned char *buf, long len)
 886 {
 887   int i;
 888   switch (endian)
 889     {
 890     case BFD_ENDIAN_BIG:
 891       for (i = 0; i < len; i++)
 892         fprintf_unfiltered (file, "%02x", buf[i]);
 893       break;
 894     case BFD_ENDIAN_LITTLE:
 895       for (i = len - 1; i >= 0; i--)
 896         fprintf_unfiltered (file, "%02x", buf[i]);
 897       break;
 898     default:
 899       internal_error (__FILE__, __LINE__, _("Bad switch"));
 900     }
 901 }
 902
 903 enum regcache_dump_what
 904 {
 905   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
 906 };
 907
 908 static void
 909 regcache_dump (struct regcache *regcache, struct ui_file *file,
 910                enum regcache_dump_what what_to_dump)
 911 {
 912   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
 913   struct gdbarch *gdbarch = regcache->descr->gdbarch;
 914   int regnum;
 915   int footnote_nr = 0;
 916   int footnote_register_size = 0;
 917   int footnote_register_offset = 0;
 918   int footnote_register_type_name_null = 0;
 919   long register_offset = 0;
 920   unsigned char buf[MAX_REGISTER_SIZE];
 921
 922 #if 0
 923   fprintf_unfiltered (file, "nr_raw_registers %d\n",
 924                       regcache->descr->nr_raw_registers);
 925   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
 926                       regcache->descr->nr_cooked_registers);
 927   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
 928                       regcache->descr->sizeof_raw_registers);
 929   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
 930                       regcache->descr->sizeof_raw_register_valid_p);
 931   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
 932                       gdbarch_num_regs (gdbarch));
 933   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
 934                       gdbarch_num_pseudo_regs (gdbarch));
 935 #endif
 936
 937   gdb_assert (regcache->descr->nr_cooked_registers
 938               == (gdbarch_num_regs (gdbarch)
 939                   + gdbarch_num_pseudo_regs (gdbarch)));
 940
 941   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
 942     {
 943       /* Name.  */
 944       if (regnum < 0)
 945         fprintf_unfiltered (file, " %-10s", "Name");
 946       else
 947         {
 948           const char *p = gdbarch_register_name (gdbarch, regnum);
 949           if (p == NULL)
 950             p = "";
 951           else if (p[0] == '\0')
 952             p = "''";
 953           fprintf_unfiltered (file, " %-10s", p);
 954         }
 955
 956       /* Number.  */
 957       if (regnum < 0)
 958         fprintf_unfiltered (file, " %4s", "Nr");
 959       else
 960         fprintf_unfiltered (file, " %4d", regnum);
 961
 962       /* Relative number.  */
 963       if (regnum < 0)
 964         fprintf_unfiltered (file, " %4s", "Rel");
 965       else if (regnum < gdbarch_num_regs (gdbarch))
 966         fprintf_unfiltered (file, " %4d", regnum);
 967       else
 968         fprintf_unfiltered (file, " %4d",
 969                             (regnum - gdbarch_num_regs (gdbarch)));
 970
 971       /* Offset.  */
 972       if (regnum < 0)
 973         fprintf_unfiltered (file, " %6s  ", "Offset");
 974       else
 975         {
 976           fprintf_unfiltered (file, " %6ld",
 977                               regcache->descr->register_offset[regnum]);
 978           if (register_offset != regcache->descr->register_offset[regnum]
 979               || (regnum > 0
 980                   && (regcache->descr->register_offset[regnum]
 981                       != (regcache->descr->register_offset[regnum - 1]
 982                           + regcache->descr->sizeof_register[regnum - 1])))
 983               )
 984             {
 985               if (!footnote_register_offset)
 986                 footnote_register_offset = ++footnote_nr;
 987               fprintf_unfiltered (file, "*%d", footnote_register_offset);
 988             }
 989           else
 990             fprintf_unfiltered (file, "  ");
 991           register_offset = (regcache->descr->register_offset[regnum]
 992                              + regcache->descr->sizeof_register[regnum]);
 993         }
 994
 995       /* Size.  */
 996       if (regnum < 0)
 997         fprintf_unfiltered (file, " %5s ", "Size");
 998       else
 999         fprintf_unfiltered (file, " %5ld",
1000                             regcache->descr->sizeof_register[regnum]);
1001
1002       /* Type.  */
1003       {
1004         const char *t;
1005         if (regnum < 0)
1006           t = "Type";
1007         else
1008           {
1009             static const char blt[] = "builtin_type";
1010             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1011             if (t == NULL)
1012               {
1013                 char *n;
1014                 if (!footnote_register_type_name_null)
1015                   footnote_register_type_name_null = ++footnote_nr;
1016                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1017                 make_cleanup (xfree, n);
1018                 t = n;
1019               }
1020             /* Chop a leading builtin_type.  */
1021             if (strncmp (t, blt, strlen (blt)) == 0)
1022               t += strlen (blt);
1023           }
1024         fprintf_unfiltered (file, " %-15s", t);
1025       }
1026
1027       /* Leading space always present.  */
1028       fprintf_unfiltered (file, " ");
1029
1030       /* Value, raw.  */
1031       if (what_to_dump == regcache_dump_raw)
1032         {
1033           if (regnum < 0)
1034             fprintf_unfiltered (file, "Raw value");
1035           else if (regnum >= regcache->descr->nr_raw_registers)
1036             fprintf_unfiltered (file, "<cooked>");
1037           else if (!regcache_valid_p (regcache, regnum))
1038             fprintf_unfiltered (file, "<invalid>");
1039           else
1040             {
1041               regcache_raw_read (regcache, regnum, buf);
1042               fprintf_unfiltered (file, "0x");
1043               dump_endian_bytes (file,
1044                                  gdbarch_byte_order (gdbarch), buf,
1045                                  regcache->descr->sizeof_register[regnum]);
1046             }
1047         }
1048
1049       /* Value, cooked.  */
1050       if (what_to_dump == regcache_dump_cooked)
1051         {
1052           if (regnum < 0)
1053             fprintf_unfiltered (file, "Cooked value");
1054           else
1055             {
1056               regcache_cooked_read (regcache, regnum, buf);
1057               fprintf_unfiltered (file, "0x");
1058               dump_endian_bytes (file,
1059                                  gdbarch_byte_order (gdbarch), buf,
1060                                  regcache->descr->sizeof_register[regnum]);
1061             }
1062         }
1063
1064       /* Group members.  */
1065       if (what_to_dump == regcache_dump_groups)
1066         {
1067           if (regnum < 0)
1068             fprintf_unfiltered (file, "Groups");
1069           else
1070             {
1071               const char *sep = "";
1072               struct reggroup *group;
1073               for (group = reggroup_next (gdbarch, NULL);
1074                    group != NULL;
1075                    group = reggroup_next (gdbarch, group))
1076                 {
1077                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1078                     {
1079                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1080                       sep = ",";
1081                     }
1082                 }
1083             }
1084         }
1085
1086       fprintf_unfiltered (file, "\n");
1087     }
1088
1089   if (footnote_register_size)
1090     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1091                         footnote_register_size);
1092   if (footnote_register_offset)
1093     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1094                         footnote_register_offset);
1095   if (footnote_register_type_name_null)
1096     fprintf_unfiltered (file,
1097                         "*%d: Register type's name NULL.\n",
1098                         footnote_register_type_name_null);
1099   do_cleanups (cleanups);
1100 }
1101
1102 static void
1103 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1104 {
1105   if (args == NULL)
1106     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1107   else
1108     {
1109       struct ui_file *file = gdb_fopen (args, "w");
1110       if (file == NULL)
1111         perror_with_name (_("maintenance print architecture"));
1112       regcache_dump (get_current_regcache (), file, what_to_dump);
1113       ui_file_delete (file);
1114     }
1115 }
1116
1117 static void
1118 maintenance_print_registers (char *args, int from_tty)
1119 {
1120   regcache_print (args, regcache_dump_none);
1121 }
1122
1123 static void
1124 maintenance_print_raw_registers (char *args, int from_tty)
1125 {
1126   regcache_print (args, regcache_dump_raw);
1127 }
1128
1129 static void
1130 maintenance_print_cooked_registers (char *args, int from_tty)
1131 {
1132   regcache_print (args, regcache_dump_cooked);
1133 }
1134
1135 static void
1136 maintenance_print_register_groups (char *args, int from_tty)
1137 {
1138   regcache_print (args, regcache_dump_groups);
1139 }
1140
1141 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1142
1143 void
1144 _initialize_regcache (void)
1145 {
1146   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1147
1148   observer_attach_target_changed (regcache_observer_target_changed);
1149
1150   add_com ("flushregs", class_maintenance, reg_flush_command,
1151            _("Force gdb to flush its register cache (maintainer command)"));
1152
1153   add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1154 Print the internal register configuration.\n\
1155 Takes an optional file parameter."), &maintenanceprintlist);
1156   add_cmd ("raw-registers", class_maintenance,
1157            maintenance_print_raw_registers, _("\
1158 Print the internal register configuration including raw values.\n\
1159 Takes an optional file parameter."), &maintenanceprintlist);
1160   add_cmd ("cooked-registers", class_maintenance,
1161            maintenance_print_cooked_registers, _("\
1162 Print the internal register configuration including cooked values.\n\
1163 Takes an optional file parameter."), &maintenanceprintlist);
1164   add_cmd ("register-groups", class_maintenance,
1165            maintenance_print_register_groups, _("\
1166 Print the internal register configuration including each register's group.\n\
1167 Takes an optional file parameter."),
1168            &maintenanceprintlist);
1169
1170 }