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, 2010 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
 189   /* The address space of this register cache (for registers where it
 190      makes sense, like PC or SP).  */
 191   struct address_space *aspace;
 192
 193   /* The register buffers.  A read-only register cache can hold the
 194      full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
 195      register cache can only hold [0 .. gdbarch_num_regs).  */
 196   gdb_byte *registers;
 197   /* Register cache status:
 198      register_valid_p[REG] == 0 if REG value is not in the cache
 199                             > 0 if REG value is in the cache
 200                             < 0 if REG value is permanently unavailable */
 201   signed char *register_valid_p;
 202   /* Is this a read-only cache?  A read-only cache is used for saving
 203      the target's register state (e.g, across an inferior function
 204      call or just before forcing a function return).  A read-only
 205      cache can only be updated via the methods regcache_dup() and
 206      regcache_cpy().  The actual contents are determined by the
 207      reggroup_save and reggroup_restore methods.  */
 208   int readonly_p;
 209   /* If this is a read-write cache, which thread's registers is
 210      it connected to?  */
 211   ptid_t ptid;
 212 };
 213
 214 struct regcache *
 215 regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
 216 {
 217   struct regcache_descr *descr;
 218   struct regcache *regcache;
 219   gdb_assert (gdbarch != NULL);
 220   descr = regcache_descr (gdbarch);
 221   regcache = XMALLOC (struct regcache);
 222   regcache->descr = descr;
 223   regcache->registers
 224     = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
 225   regcache->register_valid_p
 226     = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
 227   regcache->aspace = aspace;
 228   regcache->readonly_p = 1;
 229   regcache->ptid = minus_one_ptid;
 230   return regcache;
 231 }
 232
 233 void
 234 regcache_xfree (struct regcache *regcache)
 235 {
 236   if (regcache == NULL)
 237     return;
 238   xfree (regcache->registers);
 239   xfree (regcache->register_valid_p);
 240   xfree (regcache);
 241 }
 242
 243 static void
 244 do_regcache_xfree (void *data)
 245 {
 246   regcache_xfree (data);
 247 }
 248
 249 struct cleanup *
 250 make_cleanup_regcache_xfree (struct regcache *regcache)
 251 {
 252   return make_cleanup (do_regcache_xfree, regcache);
 253 }
 254
 255 /* Return REGCACHE's architecture.  */
 256
 257 struct gdbarch *
 258 get_regcache_arch (const struct regcache *regcache)
 259 {
 260   return regcache->descr->gdbarch;
 261 }
 262
 263 struct address_space *
 264 get_regcache_aspace (const struct regcache *regcache)
 265 {
 266   return regcache->aspace;
 267 }
 268
 269 /* Return  a pointer to register REGNUM's buffer cache.  */
 270
 271 static gdb_byte *
 272 register_buffer (const struct regcache *regcache, int regnum)
 273 {
 274   return regcache->registers + regcache->descr->register_offset[regnum];
 275 }
 276
 277 void
 278 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 279                void *src)
 280 {
 281   struct gdbarch *gdbarch = dst->descr->gdbarch;
 282   gdb_byte buf[MAX_REGISTER_SIZE];
 283   int regnum;
 284   /* The DST should be `read-only', if it wasn't then the save would
 285      end up trying to write the register values back out to the
 286      target.  */
 287   gdb_assert (dst->readonly_p);
 288   /* Clear the dest.  */
 289   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 290   memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
 291   /* Copy over any registers (identified by their membership in the
 292      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
 293      gdbarch_num_pseudo_regs) range is checked since some architectures need
 294      to save/restore `cooked' registers that live in memory.  */
 295   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 296     {
 297       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 298         {
 299           int valid = cooked_read (src, regnum, buf);
 300           if (valid)
 301             {
 302               memcpy (register_buffer (dst, regnum), buf,
 303                       register_size (gdbarch, regnum));
 304               dst->register_valid_p[regnum] = 1;
 305             }
 306         }
 307     }
 308 }
 309
 310 void
 311 regcache_restore (struct regcache *dst,
 312                   regcache_cooked_read_ftype *cooked_read,
 313                   void *cooked_read_context)
 314 {
 315   struct gdbarch *gdbarch = dst->descr->gdbarch;
 316   gdb_byte buf[MAX_REGISTER_SIZE];
 317   int regnum;
 318   /* The dst had better not be read-only.  If it is, the `restore'
 319      doesn't make much sense.  */
 320   gdb_assert (!dst->readonly_p);
 321   /* Copy over any registers, being careful to only restore those that
 322      were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
 323      + gdbarch_num_pseudo_regs) range is checked since some architectures need
 324      to save/restore `cooked' registers that live in memory.  */
 325   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 326     {
 327       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 328         {
 329           int valid = cooked_read (cooked_read_context, regnum, buf);
 330           if (valid)
 331             regcache_cooked_write (dst, regnum, buf);
 332         }
 333     }
 334 }
 335
 336 static int
 337 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 338 {
 339   struct regcache *regcache = src;
 340   if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
 341     /* Don't even think about fetching a register from a read-only
 342        cache when the register isn't yet valid.  There isn't a target
 343        from which the register value can be fetched.  */
 344     return 0;
 345   regcache_cooked_read (regcache, regnum, buf);
 346   return 1;
 347 }
 348
 349
 350 void
 351 regcache_cpy (struct regcache *dst, struct regcache *src)
 352 {
 353   int i;
 354   gdb_byte *buf;
 355
 356   gdb_assert (src != NULL && dst != NULL);
 357   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 358   gdb_assert (src != dst);
 359   gdb_assert (src->readonly_p || dst->readonly_p);
 360
 361   if (!src->readonly_p)
 362     regcache_save (dst, do_cooked_read, src);
 363   else if (!dst->readonly_p)
 364     regcache_restore (dst, do_cooked_read, src);
 365   else
 366     regcache_cpy_no_passthrough (dst, src);
 367 }
 368
 369 void
 370 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 371 {
 372   int i;
 373   gdb_assert (src != NULL && dst != NULL);
 374   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 375   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 376      move of data into the current regcache.  Doing this would be
 377      silly - it would mean that valid_p would be completely invalid.  */
 378   gdb_assert (dst->readonly_p);
 379
 380   memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
 381   memcpy (dst->register_valid_p, src->register_valid_p,
 382           dst->descr->sizeof_raw_register_valid_p);
 383 }
 384
 385 struct regcache *
 386 regcache_dup (struct regcache *src)
 387 {
 388   struct regcache *newbuf;
 389   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
 390   regcache_cpy (newbuf, src);
 391   return newbuf;
 392 }
 393
 394 struct regcache *
 395 regcache_dup_no_passthrough (struct regcache *src)
 396 {
 397   struct regcache *newbuf;
 398   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
 399   regcache_cpy_no_passthrough (newbuf, src);
 400   return newbuf;
 401 }
 402
 403 int
 404 regcache_valid_p (const struct regcache *regcache, int regnum)
 405 {
 406   gdb_assert (regcache != NULL);
 407   gdb_assert (regnum >= 0);
 408   if (regcache->readonly_p)
 409     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 410   else
 411     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 412
 413   return regcache->register_valid_p[regnum];
 414 }
 415
 416 void
 417 regcache_invalidate (struct regcache *regcache, int regnum)
 418 {
 419   gdb_assert (regcache != NULL);
 420   gdb_assert (regnum >= 0);
 421   gdb_assert (!regcache->readonly_p);
 422   gdb_assert (regnum < regcache->descr->nr_raw_registers);
 423   regcache->register_valid_p[regnum] = 0;
 424 }
 425
 426
 427 /* Global structure containing the current regcache.  */
 428
 429 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 430    recording if the register values have been changed (eg. by the
 431    user).  Therefore all registers must be written back to the
 432    target when appropriate.  */
 433
 434 struct regcache_list
 435 {
 436   struct regcache *regcache;
 437   struct regcache_list *next;
 438 };
 439
 440 static struct regcache_list *current_regcache;
 441
 442 struct regcache *
 443 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
 444 {
 445   struct regcache_list *list;
 446   struct regcache *new_regcache;
 447
 448   for (list = current_regcache; list; list = list->next)
 449     if (ptid_equal (list->regcache->ptid, ptid)
 450         && get_regcache_arch (list->regcache) == gdbarch)
 451       return list->regcache;
 452
 453   new_regcache = regcache_xmalloc (gdbarch,
 454                                    target_thread_address_space (ptid));
 455   new_regcache->readonly_p = 0;
 456   new_regcache->ptid = ptid;
 457   gdb_assert (new_regcache->aspace != NULL);
 458
 459   list = xmalloc (sizeof (struct regcache_list));
 460   list->regcache = new_regcache;
 461   list->next = current_regcache;
 462   current_regcache = list;
 463
 464   return new_regcache;
 465 }
 466
 467 static ptid_t current_thread_ptid;
 468 static struct gdbarch *current_thread_arch;
 469
 470 struct regcache *
 471 get_thread_regcache (ptid_t ptid)
 472 {
 473   if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
 474     {
 475       current_thread_ptid = ptid;
 476       current_thread_arch = target_thread_architecture (ptid);
 477     }
 478
 479   return get_thread_arch_regcache (ptid, current_thread_arch);
 480 }
 481
 482 struct regcache *
 483 get_current_regcache (void)
 484 {
 485   return get_thread_regcache (inferior_ptid);
 486 }
 487
 488
 489 /* Observer for the target_changed event.  */
 490
 491 static void
 492 regcache_observer_target_changed (struct target_ops *target)
 493 {
 494   registers_changed ();
 495 }
 496
 497 /* Update global variables old ptids to hold NEW_PTID if they were
 498    holding OLD_PTID.  */
 499 static void
 500 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
 501 {
 502   struct regcache_list *list;
 503
 504   for (list = current_regcache; list; list = list->next)
 505     if (ptid_equal (list->regcache->ptid, old_ptid))
 506       list->regcache->ptid = new_ptid;
 507 }
 508
 509 /* Low level examining and depositing of registers.
 510
 511    The caller is responsible for making sure that the inferior is
 512    stopped before calling the fetching routines, or it will get
 513    garbage.  (a change from GDB version 3, in which the caller got the
 514    value from the last stop).  */
 515
 516 /* REGISTERS_CHANGED ()
 517
 518    Indicate that registers may have changed, so invalidate the cache.  */
 519
 520 void
 521 registers_changed (void)
 522 {
 523   struct regcache_list *list, *next;
 524
 525   for (list = current_regcache; list; list = next)
 526     {
 527       next = list->next;
 528       regcache_xfree (list->regcache);
 529       xfree (list);
 530     }
 531
 532   current_regcache = NULL;
 533
 534   current_thread_ptid = null_ptid;
 535   current_thread_arch = NULL;
 536
 537   /* Need to forget about any frames we have cached, too. */
 538   reinit_frame_cache ();
 539
 540   /* Force cleanup of any alloca areas if using C alloca instead of
 541      a builtin alloca.  This particular call is used to clean up
 542      areas allocated by low level target code which may build up
 543      during lengthy interactions between gdb and the target before
 544      gdb gives control to the user (ie watchpoints).  */
 545   alloca (0);
 546 }
 547
 548
 549 void
 550 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 551 {
 552   gdb_assert (regcache != NULL && buf != NULL);
 553   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 554   /* Make certain that the register cache is up-to-date with respect
 555      to the current thread.  This switching shouldn't be necessary
 556      only there is still only one target side register cache.  Sigh!
 557      On the bright side, at least there is a regcache object.  */
 558   if (!regcache->readonly_p)
 559     {
 560       if (!regcache_valid_p (regcache, regnum))
 561         {
 562           struct cleanup *old_chain = save_inferior_ptid ();
 563           inferior_ptid = regcache->ptid;
 564           target_fetch_registers (regcache, regnum);
 565           do_cleanups (old_chain);
 566         }
 567 #if 0
 568       /* FIXME: cagney/2004-08-07: At present a number of targets
 569          forget (or didn't know that they needed) to set this leading to
 570          panics.  Also is the problem that targets need to indicate
 571          that a register is in one of the possible states: valid,
 572          undefined, unknown.  The last of which isn't yet
 573          possible.  */
 574       gdb_assert (regcache_valid_p (regcache, regnum));
 575 #endif
 576     }
 577   /* Copy the value directly into the register cache.  */
 578   memcpy (buf, register_buffer (regcache, regnum),
 579           regcache->descr->sizeof_register[regnum]);
 580 }
 581
 582 void
 583 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 584 {
 585   gdb_byte *buf;
 586   gdb_assert (regcache != NULL);
 587   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 588   buf = alloca (regcache->descr->sizeof_register[regnum]);
 589   regcache_raw_read (regcache, regnum, buf);
 590   (*val) = extract_signed_integer
 591              (buf, regcache->descr->sizeof_register[regnum],
 592               gdbarch_byte_order (regcache->descr->gdbarch));
 593 }
 594
 595 void
 596 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 597                             ULONGEST *val)
 598 {
 599   gdb_byte *buf;
 600   gdb_assert (regcache != NULL);
 601   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 602   buf = alloca (regcache->descr->sizeof_register[regnum]);
 603   regcache_raw_read (regcache, regnum, buf);
 604   (*val) = extract_unsigned_integer
 605              (buf, regcache->descr->sizeof_register[regnum],
 606               gdbarch_byte_order (regcache->descr->gdbarch));
 607 }
 608
 609 void
 610 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 611 {
 612   void *buf;
 613   gdb_assert (regcache != NULL);
 614   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 615   buf = alloca (regcache->descr->sizeof_register[regnum]);
 616   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 617                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 618   regcache_raw_write (regcache, regnum, buf);
 619 }
 620
 621 void
 622 regcache_raw_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_raw_registers);
 628   buf = alloca (regcache->descr->sizeof_register[regnum]);
 629   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 630                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 631   regcache_raw_write (regcache, regnum, buf);
 632 }
 633
 634 void
 635 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 636 {
 637   gdb_assert (regnum >= 0);
 638   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 639   if (regnum < regcache->descr->nr_raw_registers)
 640     regcache_raw_read (regcache, regnum, buf);
 641   else if (regcache->readonly_p
 642            && regnum < regcache->descr->nr_cooked_registers
 643            && regcache->register_valid_p[regnum])
 644     /* Read-only register cache, perhaps the cooked value was cached?  */
 645     memcpy (buf, register_buffer (regcache, regnum),
 646             regcache->descr->sizeof_register[regnum]);
 647   else
 648     gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 649                                   regnum, buf);
 650 }
 651
 652 void
 653 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 654                              LONGEST *val)
 655 {
 656   gdb_byte *buf;
 657   gdb_assert (regcache != NULL);
 658   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 659   buf = alloca (regcache->descr->sizeof_register[regnum]);
 660   regcache_cooked_read (regcache, regnum, buf);
 661   (*val) = extract_signed_integer
 662              (buf, regcache->descr->sizeof_register[regnum],
 663               gdbarch_byte_order (regcache->descr->gdbarch));
 664 }
 665
 666 void
 667 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 668                                ULONGEST *val)
 669 {
 670   gdb_byte *buf;
 671   gdb_assert (regcache != NULL);
 672   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 673   buf = alloca (regcache->descr->sizeof_register[regnum]);
 674   regcache_cooked_read (regcache, regnum, buf);
 675   (*val) = extract_unsigned_integer
 676              (buf, regcache->descr->sizeof_register[regnum],
 677               gdbarch_byte_order (regcache->descr->gdbarch));
 678 }
 679
 680 void
 681 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 682                               LONGEST val)
 683 {
 684   void *buf;
 685   gdb_assert (regcache != NULL);
 686   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 687   buf = alloca (regcache->descr->sizeof_register[regnum]);
 688   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 689                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 690   regcache_cooked_write (regcache, regnum, buf);
 691 }
 692
 693 void
 694 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 695                                 ULONGEST val)
 696 {
 697   void *buf;
 698   gdb_assert (regcache != NULL);
 699   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 700   buf = alloca (regcache->descr->sizeof_register[regnum]);
 701   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 702                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 703   regcache_cooked_write (regcache, regnum, buf);
 704 }
 705
 706 void
 707 regcache_raw_write (struct regcache *regcache, int regnum,
 708                     const gdb_byte *buf)
 709 {
 710   struct cleanup *old_chain;
 711
 712   gdb_assert (regcache != NULL && buf != NULL);
 713   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 714   gdb_assert (!regcache->readonly_p);
 715
 716   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 717      change the registers array if something writes to this register.  */
 718   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
 719     return;
 720
 721   /* If we have a valid copy of the register, and new value == old
 722      value, then don't bother doing the actual store. */
 723   if (regcache_valid_p (regcache, regnum)
 724       && (memcmp (register_buffer (regcache, regnum), buf,
 725                   regcache->descr->sizeof_register[regnum]) == 0))
 726     return;
 727
 728   old_chain = save_inferior_ptid ();
 729   inferior_ptid = regcache->ptid;
 730
 731   target_prepare_to_store (regcache);
 732   memcpy (register_buffer (regcache, regnum), buf,
 733           regcache->descr->sizeof_register[regnum]);
 734   regcache->register_valid_p[regnum] = 1;
 735   target_store_registers (regcache, regnum);
 736
 737   do_cleanups (old_chain);
 738 }
 739
 740 void
 741 regcache_cooked_write (struct regcache *regcache, int regnum,
 742                        const gdb_byte *buf)
 743 {
 744   gdb_assert (regnum >= 0);
 745   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 746   if (regnum < regcache->descr->nr_raw_registers)
 747     regcache_raw_write (regcache, regnum, buf);
 748   else
 749     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 750                                    regnum, buf);
 751 }
 752
 753 /* Perform a partial register transfer using a read, modify, write
 754    operation.  */
 755
 756 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 757                                     void *buf);
 758 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 759                                      const void *buf);
 760
 761 static void
 762 regcache_xfer_part (struct regcache *regcache, int regnum,
 763                     int offset, int len, void *in, const void *out,
 764                     void (*read) (struct regcache *regcache, int regnum,
 765                                   gdb_byte *buf),
 766                     void (*write) (struct regcache *regcache, int regnum,
 767                                    const gdb_byte *buf))
 768 {
 769   struct regcache_descr *descr = regcache->descr;
 770   gdb_byte reg[MAX_REGISTER_SIZE];
 771   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 772   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 773   /* Something to do?  */
 774   if (offset + len == 0)
 775     return;
 776   /* Read (when needed) ... */
 777   if (in != NULL
 778       || offset > 0
 779       || offset + len < descr->sizeof_register[regnum])
 780     {
 781       gdb_assert (read != NULL);
 782       read (regcache, regnum, reg);
 783     }
 784   /* ... modify ... */
 785   if (in != NULL)
 786     memcpy (in, reg + offset, len);
 787   if (out != NULL)
 788     memcpy (reg + offset, out, len);
 789   /* ... write (when needed).  */
 790   if (out != NULL)
 791     {
 792       gdb_assert (write != NULL);
 793       write (regcache, regnum, reg);
 794     }
 795 }
 796
 797 void
 798 regcache_raw_read_part (struct regcache *regcache, int regnum,
 799                         int offset, int len, gdb_byte *buf)
 800 {
 801   struct regcache_descr *descr = regcache->descr;
 802   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 803   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 804                       regcache_raw_read, regcache_raw_write);
 805 }
 806
 807 void
 808 regcache_raw_write_part (struct regcache *regcache, int regnum,
 809                          int offset, int len, const gdb_byte *buf)
 810 {
 811   struct regcache_descr *descr = regcache->descr;
 812   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
 813   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 814                       regcache_raw_read, regcache_raw_write);
 815 }
 816
 817 void
 818 regcache_cooked_read_part (struct regcache *regcache, int regnum,
 819                            int offset, int len, gdb_byte *buf)
 820 {
 821   struct regcache_descr *descr = regcache->descr;
 822   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 823   regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
 824                       regcache_cooked_read, regcache_cooked_write);
 825 }
 826
 827 void
 828 regcache_cooked_write_part (struct regcache *regcache, int regnum,
 829                             int offset, int len, const gdb_byte *buf)
 830 {
 831   struct regcache_descr *descr = regcache->descr;
 832   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
 833   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
 834                       regcache_cooked_read, regcache_cooked_write);
 835 }
 836
 837 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
 838
 839 void
 840 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
 841 {
 842   void *regbuf;
 843   size_t size;
 844
 845   gdb_assert (regcache != NULL);
 846   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 847   gdb_assert (!regcache->readonly_p);
 848
 849   regbuf = register_buffer (regcache, regnum);
 850   size = regcache->descr->sizeof_register[regnum];
 851
 852   if (buf)
 853     memcpy (regbuf, buf, size);
 854   else
 855     memset (regbuf, 0, size);
 856
 857   /* Mark the register as cached.  */
 858   regcache->register_valid_p[regnum] = 1;
 859 }
 860
 861 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
 862
 863 void
 864 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
 865 {
 866   const void *regbuf;
 867   size_t size;
 868
 869   gdb_assert (regcache != NULL && buf != NULL);
 870   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 871
 872   regbuf = register_buffer (regcache, regnum);
 873   size = regcache->descr->sizeof_register[regnum];
 874   memcpy (buf, regbuf, size);
 875 }
 876
 877
 878 /* Special handling for register PC.  */
 879
 880 CORE_ADDR
 881 regcache_read_pc (struct regcache *regcache)
 882 {
 883   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 884
 885   CORE_ADDR pc_val;
 886
 887   if (gdbarch_read_pc_p (gdbarch))
 888     pc_val = gdbarch_read_pc (gdbarch, regcache);
 889   /* Else use per-frame method on get_current_frame.  */
 890   else if (gdbarch_pc_regnum (gdbarch) >= 0)
 891     {
 892       ULONGEST raw_val;
 893       regcache_cooked_read_unsigned (regcache,
 894                                      gdbarch_pc_regnum (gdbarch),
 895                                      &raw_val);
 896       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
 897     }
 898   else
 899     internal_error (__FILE__, __LINE__,
 900                     _("regcache_read_pc: Unable to find PC"));
 901   return pc_val;
 902 }
 903
 904 void
 905 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
 906 {
 907   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 908
 909   if (gdbarch_write_pc_p (gdbarch))
 910     gdbarch_write_pc (gdbarch, regcache, pc);
 911   else if (gdbarch_pc_regnum (gdbarch) >= 0)
 912     regcache_cooked_write_unsigned (regcache,
 913                                     gdbarch_pc_regnum (gdbarch), pc);
 914   else
 915     internal_error (__FILE__, __LINE__,
 916                     _("regcache_write_pc: Unable to update PC"));
 917
 918   /* Writing the PC (for instance, from "load") invalidates the
 919      current frame.  */
 920   reinit_frame_cache ();
 921 }
 922
 923
 924 static void
 925 reg_flush_command (char *command, int from_tty)
 926 {
 927   /* Force-flush the register cache.  */
 928   registers_changed ();
 929   if (from_tty)
 930     printf_filtered (_("Register cache flushed.\n"));
 931 }
 932
 933 static void
 934 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
 935                    const unsigned char *buf, long len)
 936 {
 937   int i;
 938   switch (endian)
 939     {
 940     case BFD_ENDIAN_BIG:
 941       for (i = 0; i < len; i++)
 942         fprintf_unfiltered (file, "%02x", buf[i]);
 943       break;
 944     case BFD_ENDIAN_LITTLE:
 945       for (i = len - 1; i >= 0; i--)
 946         fprintf_unfiltered (file, "%02x", buf[i]);
 947       break;
 948     default:
 949       internal_error (__FILE__, __LINE__, _("Bad switch"));
 950     }
 951 }
 952
 953 enum regcache_dump_what
 954 {
 955   regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
 956 };
 957
 958 static void
 959 regcache_dump (struct regcache *regcache, struct ui_file *file,
 960                enum regcache_dump_what what_to_dump)
 961 {
 962   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
 963   struct gdbarch *gdbarch = regcache->descr->gdbarch;
 964   int regnum;
 965   int footnote_nr = 0;
 966   int footnote_register_size = 0;
 967   int footnote_register_offset = 0;
 968   int footnote_register_type_name_null = 0;
 969   long register_offset = 0;
 970   unsigned char buf[MAX_REGISTER_SIZE];
 971
 972 #if 0
 973   fprintf_unfiltered (file, "nr_raw_registers %d\n",
 974                       regcache->descr->nr_raw_registers);
 975   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
 976                       regcache->descr->nr_cooked_registers);
 977   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
 978                       regcache->descr->sizeof_raw_registers);
 979   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
 980                       regcache->descr->sizeof_raw_register_valid_p);
 981   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
 982                       gdbarch_num_regs (gdbarch));
 983   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
 984                       gdbarch_num_pseudo_regs (gdbarch));
 985 #endif
 986
 987   gdb_assert (regcache->descr->nr_cooked_registers
 988               == (gdbarch_num_regs (gdbarch)
 989                   + gdbarch_num_pseudo_regs (gdbarch)));
 990
 991   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
 992     {
 993       /* Name.  */
 994       if (regnum < 0)
 995         fprintf_unfiltered (file, " %-10s", "Name");
 996       else
 997         {
 998           const char *p = gdbarch_register_name (gdbarch, regnum);
 999           if (p == NULL)
1000             p = "";
1001           else if (p[0] == '\0')
1002             p = "''";
1003           fprintf_unfiltered (file, " %-10s", p);
1004         }
1005
1006       /* Number.  */
1007       if (regnum < 0)
1008         fprintf_unfiltered (file, " %4s", "Nr");
1009       else
1010         fprintf_unfiltered (file, " %4d", regnum);
1011
1012       /* Relative number.  */
1013       if (regnum < 0)
1014         fprintf_unfiltered (file, " %4s", "Rel");
1015       else if (regnum < gdbarch_num_regs (gdbarch))
1016         fprintf_unfiltered (file, " %4d", regnum);
1017       else
1018         fprintf_unfiltered (file, " %4d",
1019                             (regnum - gdbarch_num_regs (gdbarch)));
1020
1021       /* Offset.  */
1022       if (regnum < 0)
1023         fprintf_unfiltered (file, " %6s  ", "Offset");
1024       else
1025         {
1026           fprintf_unfiltered (file, " %6ld",
1027                               regcache->descr->register_offset[regnum]);
1028           if (register_offset != regcache->descr->register_offset[regnum]
1029               || (regnum > 0
1030                   && (regcache->descr->register_offset[regnum]
1031                       != (regcache->descr->register_offset[regnum - 1]
1032                           + regcache->descr->sizeof_register[regnum - 1])))
1033               )
1034             {
1035               if (!footnote_register_offset)
1036                 footnote_register_offset = ++footnote_nr;
1037               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1038             }
1039           else
1040             fprintf_unfiltered (file, "  ");
1041           register_offset = (regcache->descr->register_offset[regnum]
1042                              + regcache->descr->sizeof_register[regnum]);
1043         }
1044
1045       /* Size.  */
1046       if (regnum < 0)
1047         fprintf_unfiltered (file, " %5s ", "Size");
1048       else
1049         fprintf_unfiltered (file, " %5ld",
1050                             regcache->descr->sizeof_register[regnum]);
1051
1052       /* Type.  */
1053       {
1054         const char *t;
1055         if (regnum < 0)
1056           t = "Type";
1057         else
1058           {
1059             static const char blt[] = "builtin_type";
1060             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1061             if (t == NULL)
1062               {
1063                 char *n;
1064                 if (!footnote_register_type_name_null)
1065                   footnote_register_type_name_null = ++footnote_nr;
1066                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1067                 make_cleanup (xfree, n);
1068                 t = n;
1069               }
1070             /* Chop a leading builtin_type.  */
1071             if (strncmp (t, blt, strlen (blt)) == 0)
1072               t += strlen (blt);
1073           }
1074         fprintf_unfiltered (file, " %-15s", t);
1075       }
1076
1077       /* Leading space always present.  */
1078       fprintf_unfiltered (file, " ");
1079
1080       /* Value, raw.  */
1081       if (what_to_dump == regcache_dump_raw)
1082         {
1083           if (regnum < 0)
1084             fprintf_unfiltered (file, "Raw value");
1085           else if (regnum >= regcache->descr->nr_raw_registers)
1086             fprintf_unfiltered (file, "<cooked>");
1087           else if (!regcache_valid_p (regcache, regnum))
1088             fprintf_unfiltered (file, "<invalid>");
1089           else
1090             {
1091               regcache_raw_read (regcache, regnum, buf);
1092               fprintf_unfiltered (file, "0x");
1093               dump_endian_bytes (file,
1094                                  gdbarch_byte_order (gdbarch), buf,
1095                                  regcache->descr->sizeof_register[regnum]);
1096             }
1097         }
1098
1099       /* Value, cooked.  */
1100       if (what_to_dump == regcache_dump_cooked)
1101         {
1102           if (regnum < 0)
1103             fprintf_unfiltered (file, "Cooked value");
1104           else
1105             {
1106               regcache_cooked_read (regcache, regnum, buf);
1107               fprintf_unfiltered (file, "0x");
1108               dump_endian_bytes (file,
1109                                  gdbarch_byte_order (gdbarch), buf,
1110                                  regcache->descr->sizeof_register[regnum]);
1111             }
1112         }
1113
1114       /* Group members.  */
1115       if (what_to_dump == regcache_dump_groups)
1116         {
1117           if (regnum < 0)
1118             fprintf_unfiltered (file, "Groups");
1119           else
1120             {
1121               const char *sep = "";
1122               struct reggroup *group;
1123               for (group = reggroup_next (gdbarch, NULL);
1124                    group != NULL;
1125                    group = reggroup_next (gdbarch, group))
1126                 {
1127                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1128                     {
1129                       fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1130                       sep = ",";
1131                     }
1132                 }
1133             }
1134         }
1135
1136       fprintf_unfiltered (file, "\n");
1137     }
1138
1139   if (footnote_register_size)
1140     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1141                         footnote_register_size);
1142   if (footnote_register_offset)
1143     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1144                         footnote_register_offset);
1145   if (footnote_register_type_name_null)
1146     fprintf_unfiltered (file,
1147                         "*%d: Register type's name NULL.\n",
1148                         footnote_register_type_name_null);
1149   do_cleanups (cleanups);
1150 }
1151
1152 static void
1153 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1154 {
1155   if (args == NULL)
1156     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1157   else
1158     {
1159       struct cleanup *cleanups;
1160       struct ui_file *file = gdb_fopen (args, "w");
1161       if (file == NULL)
1162         perror_with_name (_("maintenance print architecture"));
1163       cleanups = make_cleanup_ui_file_delete (file);
1164       regcache_dump (get_current_regcache (), file, what_to_dump);
1165       do_cleanups (cleanups);
1166     }
1167 }
1168
1169 static void
1170 maintenance_print_registers (char *args, int from_tty)
1171 {
1172   regcache_print (args, regcache_dump_none);
1173 }
1174
1175 static void
1176 maintenance_print_raw_registers (char *args, int from_tty)
1177 {
1178   regcache_print (args, regcache_dump_raw);
1179 }
1180
1181 static void
1182 maintenance_print_cooked_registers (char *args, int from_tty)
1183 {
1184   regcache_print (args, regcache_dump_cooked);
1185 }
1186
1187 static void
1188 maintenance_print_register_groups (char *args, int from_tty)
1189 {
1190   regcache_print (args, regcache_dump_groups);
1191 }
1192
1193 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1194
1195 void
1196 _initialize_regcache (void)
1197 {
1198   regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1199
1200   observer_attach_target_changed (regcache_observer_target_changed);
1201   observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1202
1203   add_com ("flushregs", class_maintenance, reg_flush_command,
1204            _("Force gdb to flush its register cache (maintainer command)"));
1205
1206   add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1207 Print the internal register configuration.\n\
1208 Takes an optional file parameter."), &maintenanceprintlist);
1209   add_cmd ("raw-registers", class_maintenance,
1210            maintenance_print_raw_registers, _("\
1211 Print the internal register configuration including raw values.\n\
1212 Takes an optional file parameter."), &maintenanceprintlist);
1213   add_cmd ("cooked-registers", class_maintenance,
1214            maintenance_print_cooked_registers, _("\
1215 Print the internal register configuration including cooked values.\n\
1216 Takes an optional file parameter."), &maintenanceprintlist);
1217   add_cmd ("register-groups", class_maintenance,
1218            maintenance_print_register_groups, _("\
1219 Print the internal register configuration including each register's group.\n\
1220 Takes an optional file parameter."),
1221            &maintenanceprintlist);
1222
1223 }