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