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