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