gdb/regcache.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "target.h"
  23 #include "gdbarch.h"
  24 #include "gdbcmd.h"
  25 #include "regcache.h"
  26 #include "reggroups.h"
  27 #include "observer.h"
  28 #include "remote.h"
  29 #include "valprint.h"
  30 #include "regset.h"
  31
  32 /*
  33  * DATA STRUCTURE
  34  *
  35  * Here is the actual register cache.
  36  */
  37
  38 /* Per-architecture object describing the layout of a register cache.
  39    Computed once when the architecture is created.  */
  40
  41 struct gdbarch_data *regcache_descr_handle;
  42
  43 struct regcache_descr
  44 {
  45   /* The architecture this descriptor belongs to.  */
  46   struct gdbarch *gdbarch;
  47
  48   /* The raw register cache.  Each raw (or hard) register is supplied
  49      by the target interface.  The raw cache should not contain
  50      redundant information - if the PC is constructed from two
  51      registers then those registers and not the PC lives in the raw
  52      cache.  */
  53   int nr_raw_registers;
  54   long sizeof_raw_registers;
  55   long sizeof_raw_register_status;
  56
  57   /* The cooked register space.  Each cooked register in the range
  58      [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
  59      register.  The remaining [NR_RAW_REGISTERS
  60      .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
  61      both raw registers and memory by the architecture methods
  62      gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
  63   int nr_cooked_registers;
  64   long sizeof_cooked_registers;
  65   long sizeof_cooked_register_status;
  66
  67   /* Offset and size (in 8 bit bytes), of each register in the
  68      register cache.  All registers (including those in the range
  69      [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
  70      offset.  */
  71   long *register_offset;
  72   long *sizeof_register;
  73
  74   /* Cached table containing the type of each register.  */
  75   struct type **register_type;
  76 };
  77
  78 static void *
  79 init_regcache_descr (struct gdbarch *gdbarch)
  80 {
  81   int i;
  82   struct regcache_descr *descr;
  83   gdb_assert (gdbarch != NULL);
  84
  85   /* Create an initial, zero filled, table.  */
  86   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  87   descr->gdbarch = gdbarch;
  88
  89   /* Total size of the register space.  The raw registers are mapped
  90      directly onto the raw register cache while the pseudo's are
  91      either mapped onto raw-registers or memory.  */
  92   descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
  93                                + gdbarch_num_pseudo_regs (gdbarch);
  94   descr->sizeof_cooked_register_status
  95     = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
  96
  97   /* Fill in a table of register types.  */
  98   descr->register_type
  99     = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers,
 100                               struct type *);
 101   for (i = 0; i < descr->nr_cooked_registers; i++)
 102     descr->register_type[i] = gdbarch_register_type (gdbarch, i);
 103
 104   /* Construct a strictly RAW register cache.  Don't allow pseudo's
 105      into the register cache.  */
 106   descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
 107   descr->sizeof_raw_register_status = gdbarch_num_regs (gdbarch);
 108
 109   /* Lay out the register cache.
 110
 111      NOTE: cagney/2002-05-22: Only register_type() is used when
 112      constructing the register cache.  It is assumed that the
 113      register's raw size, virtual size and type length are all the
 114      same.  */
 115
 116   {
 117     long offset = 0;
 118
 119     descr->sizeof_register
 120       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 121     descr->register_offset
 122       = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
 123     for (i = 0; i < descr->nr_raw_registers; i++)
 124       {
 125         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 126         descr->register_offset[i] = offset;
 127         offset += descr->sizeof_register[i];
 128         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 129       }
 130     /* Set the real size of the raw register cache buffer.  */
 131     descr->sizeof_raw_registers = offset;
 132
 133     for (; i < descr->nr_cooked_registers; i++)
 134       {
 135         descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 136         descr->register_offset[i] = offset;
 137         offset += descr->sizeof_register[i];
 138         gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
 139       }
 140     /* Set the real size of the readonly register cache buffer.  */
 141     descr->sizeof_cooked_registers = offset;
 142   }
 143
 144   return descr;
 145 }
 146
 147 static struct regcache_descr *
 148 regcache_descr (struct gdbarch *gdbarch)
 149 {
 150   return (struct regcache_descr *) gdbarch_data (gdbarch,
 151                                                  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 /* See common/common-regcache.h.  */
 183
 184 int
 185 regcache_register_size (const struct regcache *regcache, int n)
 186 {
 187   return register_size (get_regcache_arch (regcache), n);
 188 }
 189
 190 /* The register cache for storing raw register values.  */
 191
 192 struct regcache
 193 {
 194   struct regcache_descr *descr;
 195
 196   /* The address space of this register cache (for registers where it
 197      makes sense, like PC or SP).  */
 198   struct address_space *aspace;
 199
 200   /* The register buffers.  A read-only register cache can hold the
 201      full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
 202      register cache can only hold [0 .. gdbarch_num_regs).  */
 203   gdb_byte *registers;
 204   /* Register cache status.  */
 205   signed char *register_status;
 206   /* Is this a read-only cache?  A read-only cache is used for saving
 207      the target's register state (e.g, across an inferior function
 208      call or just before forcing a function return).  A read-only
 209      cache can only be updated via the methods regcache_dup() and
 210      regcache_cpy().  The actual contents are determined by the
 211      reggroup_save and reggroup_restore methods.  */
 212   int readonly_p;
 213   /* If this is a read-write cache, which thread's registers is
 214      it connected to?  */
 215   ptid_t ptid;
 216 };
 217
 218 static struct regcache *
 219 regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
 220                     int readonly_p)
 221 {
 222   struct regcache_descr *descr;
 223   struct regcache *regcache;
 224
 225   gdb_assert (gdbarch != NULL);
 226   descr = regcache_descr (gdbarch);
 227   regcache = XNEW (struct regcache);
 228   regcache->descr = descr;
 229   regcache->readonly_p = readonly_p;
 230   if (readonly_p)
 231     {
 232       regcache->registers
 233         = XCNEWVEC (gdb_byte, descr->sizeof_cooked_registers);
 234       regcache->register_status
 235         = XCNEWVEC (signed char, descr->sizeof_cooked_register_status);
 236     }
 237   else
 238     {
 239       regcache->registers
 240         = XCNEWVEC (gdb_byte, descr->sizeof_raw_registers);
 241       regcache->register_status
 242         = XCNEWVEC (signed char, descr->sizeof_raw_register_status);
 243     }
 244   regcache->aspace = aspace;
 245   regcache->ptid = minus_one_ptid;
 246   return regcache;
 247 }
 248
 249 struct regcache *
 250 regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
 251 {
 252   return regcache_xmalloc_1 (gdbarch, aspace, 1);
 253 }
 254
 255 void
 256 regcache_xfree (struct regcache *regcache)
 257 {
 258   if (regcache == NULL)
 259     return;
 260   xfree (regcache->registers);
 261   xfree (regcache->register_status);
 262   xfree (regcache);
 263 }
 264
 265 static void
 266 do_regcache_xfree (void *data)
 267 {
 268   regcache_xfree ((struct regcache *) data);
 269 }
 270
 271 struct cleanup *
 272 make_cleanup_regcache_xfree (struct regcache *regcache)
 273 {
 274   return make_cleanup (do_regcache_xfree, regcache);
 275 }
 276
 277 /* Cleanup routines for invalidating a register.  */
 278
 279 struct register_to_invalidate
 280 {
 281   struct regcache *regcache;
 282   int regnum;
 283 };
 284
 285 static void
 286 do_regcache_invalidate (void *data)
 287 {
 288   struct register_to_invalidate *reg = (struct register_to_invalidate *) data;
 289
 290   regcache_invalidate (reg->regcache, reg->regnum);
 291 }
 292
 293 static struct cleanup *
 294 make_cleanup_regcache_invalidate (struct regcache *regcache, int regnum)
 295 {
 296   struct register_to_invalidate* reg = XNEW (struct register_to_invalidate);
 297
 298   reg->regcache = regcache;
 299   reg->regnum = regnum;
 300   return make_cleanup_dtor (do_regcache_invalidate, (void *) reg, xfree);
 301 }
 302
 303 /* Return REGCACHE's architecture.  */
 304
 305 struct gdbarch *
 306 get_regcache_arch (const struct regcache *regcache)
 307 {
 308   return regcache->descr->gdbarch;
 309 }
 310
 311 struct address_space *
 312 get_regcache_aspace (const struct regcache *regcache)
 313 {
 314   return regcache->aspace;
 315 }
 316
 317 /* Return  a pointer to register REGNUM's buffer cache.  */
 318
 319 static gdb_byte *
 320 register_buffer (const struct regcache *regcache, int regnum)
 321 {
 322   return regcache->registers + regcache->descr->register_offset[regnum];
 323 }
 324
 325 void
 326 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 327                void *src)
 328 {
 329   struct gdbarch *gdbarch = dst->descr->gdbarch;
 330   gdb_byte buf[MAX_REGISTER_SIZE];
 331   int regnum;
 332
 333   /* The DST should be `read-only', if it wasn't then the save would
 334      end up trying to write the register values back out to the
 335      target.  */
 336   gdb_assert (dst->readonly_p);
 337   /* Clear the dest.  */
 338   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
 339   memset (dst->register_status, 0,
 340           dst->descr->sizeof_cooked_register_status);
 341   /* Copy over any registers (identified by their membership in the
 342      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
 343      gdbarch_num_pseudo_regs) range is checked since some architectures need
 344      to save/restore `cooked' registers that live in memory.  */
 345   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 346     {
 347       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
 348         {
 349           enum register_status status = cooked_read (src, regnum, buf);
 350
 351           if (status == REG_VALID)
 352             memcpy (register_buffer (dst, regnum), buf,
 353                     register_size (gdbarch, regnum));
 354           else
 355             {
 356               gdb_assert (status != REG_UNKNOWN);
 357
 358               memset (register_buffer (dst, regnum), 0,
 359                       register_size (gdbarch, regnum));
 360             }
 361           dst->register_status[regnum] = status;
 362         }
 363     }
 364 }
 365
 366 static void
 367 regcache_restore (struct regcache *dst,
 368                   regcache_cooked_read_ftype *cooked_read,
 369                   void *cooked_read_context)
 370 {
 371   struct gdbarch *gdbarch = dst->descr->gdbarch;
 372   gdb_byte buf[MAX_REGISTER_SIZE];
 373   int regnum;
 374
 375   /* The dst had better not be read-only.  If it is, the `restore'
 376      doesn't make much sense.  */
 377   gdb_assert (!dst->readonly_p);
 378   /* Copy over any registers, being careful to only restore those that
 379      were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
 380      + gdbarch_num_pseudo_regs) range is checked since some architectures need
 381      to save/restore `cooked' registers that live in memory.  */
 382   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
 383     {
 384       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
 385         {
 386           enum register_status status;
 387
 388           status = cooked_read (cooked_read_context, regnum, buf);
 389           if (status == REG_VALID)
 390             regcache_cooked_write (dst, regnum, buf);
 391         }
 392     }
 393 }
 394
 395 static enum register_status
 396 do_cooked_read (void *src, int regnum, gdb_byte *buf)
 397 {
 398   struct regcache *regcache = (struct regcache *) src;
 399
 400   return regcache_cooked_read (regcache, regnum, buf);
 401 }
 402
 403 static void regcache_cpy_no_passthrough (struct regcache *dst,
 404                                          struct regcache *src);
 405
 406 void
 407 regcache_cpy (struct regcache *dst, struct regcache *src)
 408 {
 409   gdb_assert (src != NULL && dst != NULL);
 410   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 411   gdb_assert (src != dst);
 412   gdb_assert (src->readonly_p || dst->readonly_p);
 413
 414   if (!src->readonly_p)
 415     regcache_save (dst, do_cooked_read, src);
 416   else if (!dst->readonly_p)
 417     regcache_restore (dst, do_cooked_read, src);
 418   else
 419     regcache_cpy_no_passthrough (dst, src);
 420 }
 421
 422 /* Copy/duplicate the contents of a register cache.  Unlike regcache_cpy,
 423    which is pass-through, this does not go through to the target.
 424    Only values values already in the cache are transferred.  The SRC and DST
 425    buffers must not overlap.  */
 426
 427 static void
 428 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
 429 {
 430   gdb_assert (src != NULL && dst != NULL);
 431   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
 432   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
 433      move of data into a thread's regcache.  Doing this would be silly
 434      - it would mean that regcache->register_status would be
 435      completely invalid.  */
 436   gdb_assert (dst->readonly_p && src->readonly_p);
 437
 438   memcpy (dst->registers, src->registers,
 439           dst->descr->sizeof_cooked_registers);
 440   memcpy (dst->register_status, src->register_status,
 441           dst->descr->sizeof_cooked_register_status);
 442 }
 443
 444 struct regcache *
 445 regcache_dup (struct regcache *src)
 446 {
 447   struct regcache *newbuf;
 448
 449   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
 450   regcache_cpy (newbuf, src);
 451   return newbuf;
 452 }
 453
 454 enum register_status
 455 regcache_register_status (const struct regcache *regcache, int regnum)
 456 {
 457   gdb_assert (regcache != NULL);
 458   gdb_assert (regnum >= 0);
 459   if (regcache->readonly_p)
 460     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 461   else
 462     gdb_assert (regnum < regcache->descr->nr_raw_registers);
 463
 464   return (enum register_status) regcache->register_status[regnum];
 465 }
 466
 467 void
 468 regcache_invalidate (struct regcache *regcache, int regnum)
 469 {
 470   gdb_assert (regcache != NULL);
 471   gdb_assert (regnum >= 0);
 472   gdb_assert (!regcache->readonly_p);
 473   gdb_assert (regnum < regcache->descr->nr_raw_registers);
 474   regcache->register_status[regnum] = REG_UNKNOWN;
 475 }
 476
 477
 478 /* Global structure containing the current regcache.  */
 479
 480 /* NOTE: this is a write-through cache.  There is no "dirty" bit for
 481    recording if the register values have been changed (eg. by the
 482    user).  Therefore all registers must be written back to the
 483    target when appropriate.  */
 484
 485 struct regcache_list
 486 {
 487   struct regcache *regcache;
 488   struct regcache_list *next;
 489 };
 490
 491 static struct regcache_list *current_regcache;
 492
 493 struct regcache *
 494 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
 495                                  struct address_space *aspace)
 496 {
 497   struct regcache_list *list;
 498   struct regcache *new_regcache;
 499
 500   for (list = current_regcache; list; list = list->next)
 501     if (ptid_equal (list->regcache->ptid, ptid)
 502         && get_regcache_arch (list->regcache) == gdbarch)
 503       return list->regcache;
 504
 505   new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
 506   new_regcache->ptid = ptid;
 507
 508   list = XNEW (struct regcache_list);
 509   list->regcache = new_regcache;
 510   list->next = current_regcache;
 511   current_regcache = list;
 512
 513   return new_regcache;
 514 }
 515
 516 struct regcache *
 517 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
 518 {
 519   struct address_space *aspace;
 520
 521   /* For the benefit of "maint print registers" & co when debugging an
 522      executable, allow dumping the regcache even when there is no
 523      thread selected (target_thread_address_space internal-errors if
 524      no address space is found).  Note that normal user commands will
 525      fail higher up on the call stack due to no
 526      target_has_registers.  */
 527   aspace = (ptid_equal (null_ptid, ptid)
 528             ? NULL
 529             : target_thread_address_space (ptid));
 530
 531   return get_thread_arch_aspace_regcache  (ptid, gdbarch, aspace);
 532 }
 533
 534 static ptid_t current_thread_ptid;
 535 static struct gdbarch *current_thread_arch;
 536
 537 struct regcache *
 538 get_thread_regcache (ptid_t ptid)
 539 {
 540   if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
 541     {
 542       current_thread_ptid = ptid;
 543       current_thread_arch = target_thread_architecture (ptid);
 544     }
 545
 546   return get_thread_arch_regcache (ptid, current_thread_arch);
 547 }
 548
 549 struct regcache *
 550 get_current_regcache (void)
 551 {
 552   return get_thread_regcache (inferior_ptid);
 553 }
 554
 555 /* See common/common-regcache.h.  */
 556
 557 struct regcache *
 558 get_thread_regcache_for_ptid (ptid_t ptid)
 559 {
 560   return get_thread_regcache (ptid);
 561 }
 562
 563 /* Observer for the target_changed event.  */
 564
 565 static void
 566 regcache_observer_target_changed (struct target_ops *target)
 567 {
 568   registers_changed ();
 569 }
 570
 571 /* Update global variables old ptids to hold NEW_PTID if they were
 572    holding OLD_PTID.  */
 573 static void
 574 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
 575 {
 576   struct regcache_list *list;
 577
 578   for (list = current_regcache; list; list = list->next)
 579     if (ptid_equal (list->regcache->ptid, old_ptid))
 580       list->regcache->ptid = new_ptid;
 581 }
 582
 583 /* Low level examining and depositing of registers.
 584
 585    The caller is responsible for making sure that the inferior is
 586    stopped before calling the fetching routines, or it will get
 587    garbage.  (a change from GDB version 3, in which the caller got the
 588    value from the last stop).  */
 589
 590 /* REGISTERS_CHANGED ()
 591
 592    Indicate that registers may have changed, so invalidate the cache.  */
 593
 594 void
 595 registers_changed_ptid (ptid_t ptid)
 596 {
 597   struct regcache_list *list, **list_link;
 598
 599   list = current_regcache;
 600   list_link = &current_regcache;
 601   while (list)
 602     {
 603       if (ptid_match (list->regcache->ptid, ptid))
 604         {
 605           struct regcache_list *dead = list;
 606
 607           *list_link = list->next;
 608           regcache_xfree (list->regcache);
 609           list = *list_link;
 610           xfree (dead);
 611           continue;
 612         }
 613
 614       list_link = &list->next;
 615       list = *list_link;
 616     }
 617
 618   if (ptid_match (current_thread_ptid, ptid))
 619     {
 620       current_thread_ptid = null_ptid;
 621       current_thread_arch = NULL;
 622     }
 623
 624   if (ptid_match (inferior_ptid, ptid))
 625     {
 626       /* We just deleted the regcache of the current thread.  Need to
 627          forget about any frames we have cached, too.  */
 628       reinit_frame_cache ();
 629     }
 630 }
 631
 632 void
 633 registers_changed (void)
 634 {
 635   registers_changed_ptid (minus_one_ptid);
 636
 637   /* Force cleanup of any alloca areas if using C alloca instead of
 638      a builtin alloca.  This particular call is used to clean up
 639      areas allocated by low level target code which may build up
 640      during lengthy interactions between gdb and the target before
 641      gdb gives control to the user (ie watchpoints).  */
 642   alloca (0);
 643 }
 644
 645 enum register_status
 646 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 647 {
 648   gdb_assert (regcache != NULL && buf != NULL);
 649   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 650   /* Make certain that the register cache is up-to-date with respect
 651      to the current thread.  This switching shouldn't be necessary
 652      only there is still only one target side register cache.  Sigh!
 653      On the bright side, at least there is a regcache object.  */
 654   if (!regcache->readonly_p
 655       && regcache_register_status (regcache, regnum) == REG_UNKNOWN)
 656     {
 657       struct cleanup *old_chain = save_inferior_ptid ();
 658
 659       inferior_ptid = regcache->ptid;
 660       target_fetch_registers (regcache, regnum);
 661       do_cleanups (old_chain);
 662
 663       /* A number of targets can't access the whole set of raw
 664          registers (because the debug API provides no means to get at
 665          them).  */
 666       if (regcache->register_status[regnum] == REG_UNKNOWN)
 667         regcache->register_status[regnum] = REG_UNAVAILABLE;
 668     }
 669
 670   if (regcache->register_status[regnum] != REG_VALID)
 671     memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 672   else
 673     memcpy (buf, register_buffer (regcache, regnum),
 674             regcache->descr->sizeof_register[regnum]);
 675
 676   return (enum register_status) regcache->register_status[regnum];
 677 }
 678
 679 enum register_status
 680 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
 681 {
 682   gdb_byte *buf;
 683   enum register_status status;
 684
 685   gdb_assert (regcache != NULL);
 686   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 687   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 688   status = regcache_raw_read (regcache, regnum, buf);
 689   if (status == REG_VALID)
 690     *val = extract_signed_integer
 691       (buf, regcache->descr->sizeof_register[regnum],
 692        gdbarch_byte_order (regcache->descr->gdbarch));
 693   else
 694     *val = 0;
 695   return status;
 696 }
 697
 698 enum register_status
 699 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
 700                             ULONGEST *val)
 701 {
 702   gdb_byte *buf;
 703   enum register_status status;
 704
 705   gdb_assert (regcache != NULL);
 706   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 707   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 708   status = regcache_raw_read (regcache, regnum, buf);
 709   if (status == REG_VALID)
 710     *val = extract_unsigned_integer
 711       (buf, regcache->descr->sizeof_register[regnum],
 712        gdbarch_byte_order (regcache->descr->gdbarch));
 713   else
 714     *val = 0;
 715   return status;
 716 }
 717
 718 void
 719 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
 720 {
 721   gdb_byte *buf;
 722
 723   gdb_assert (regcache != NULL);
 724   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 725   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 726   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 727                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 728   regcache_raw_write (regcache, regnum, buf);
 729 }
 730
 731 void
 732 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
 733                              ULONGEST val)
 734 {
 735   gdb_byte *buf;
 736
 737   gdb_assert (regcache != NULL);
 738   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
 739   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 740   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 741                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 742   regcache_raw_write (regcache, regnum, buf);
 743 }
 744
 745 LONGEST
 746 regcache_raw_get_signed (struct regcache *regcache, int regnum)
 747 {
 748   LONGEST value;
 749   enum register_status status;
 750
 751   status = regcache_raw_read_signed (regcache, regnum, &value);
 752   if (status == REG_UNAVAILABLE)
 753     throw_error (NOT_AVAILABLE_ERROR,
 754                  _("Register %d is not available"), regnum);
 755   return value;
 756 }
 757
 758 enum register_status
 759 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
 760 {
 761   gdb_assert (regnum >= 0);
 762   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 763   if (regnum < regcache->descr->nr_raw_registers)
 764     return regcache_raw_read (regcache, regnum, buf);
 765   else if (regcache->readonly_p
 766            && regcache->register_status[regnum] != REG_UNKNOWN)
 767     {
 768       /* Read-only register cache, perhaps the cooked value was
 769          cached?  */
 770       if (regcache->register_status[regnum] == REG_VALID)
 771         memcpy (buf, register_buffer (regcache, regnum),
 772                 regcache->descr->sizeof_register[regnum]);
 773       else
 774         memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 775
 776       return (enum register_status) regcache->register_status[regnum];
 777     }
 778   else if (gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
 779     {
 780       struct value *mark, *computed;
 781       enum register_status result = REG_VALID;
 782
 783       mark = value_mark ();
 784
 785       computed = gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
 786                                                      regcache, regnum);
 787       if (value_entirely_available (computed))
 788         memcpy (buf, value_contents_raw (computed),
 789                 regcache->descr->sizeof_register[regnum]);
 790       else
 791         {
 792           memset (buf, 0, regcache->descr->sizeof_register[regnum]);
 793           result = REG_UNAVAILABLE;
 794         }
 795
 796       value_free_to_mark (mark);
 797
 798       return result;
 799     }
 800   else
 801     return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
 802                                          regnum, buf);
 803 }
 804
 805 struct value *
 806 regcache_cooked_read_value (struct regcache *regcache, int regnum)
 807 {
 808   gdb_assert (regnum >= 0);
 809   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 810
 811   if (regnum < regcache->descr->nr_raw_registers
 812       || (regcache->readonly_p
 813           && regcache->register_status[regnum] != REG_UNKNOWN)
 814       || !gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
 815     {
 816       struct value *result;
 817
 818       result = allocate_value (register_type (regcache->descr->gdbarch,
 819                                               regnum));
 820       VALUE_LVAL (result) = lval_register;
 821       VALUE_REGNUM (result) = regnum;
 822
 823       /* It is more efficient in general to do this delegation in this
 824          direction than in the other one, even though the value-based
 825          API is preferred.  */
 826       if (regcache_cooked_read (regcache, regnum,
 827                                 value_contents_raw (result)) == REG_UNAVAILABLE)
 828         mark_value_bytes_unavailable (result, 0,
 829                                       TYPE_LENGTH (value_type (result)));
 830
 831       return result;
 832     }
 833   else
 834     return gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
 835                                                regcache, regnum);
 836 }
 837
 838 enum register_status
 839 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
 840                              LONGEST *val)
 841 {
 842   enum register_status status;
 843   gdb_byte *buf;
 844
 845   gdb_assert (regcache != NULL);
 846   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 847   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 848   status = regcache_cooked_read (regcache, regnum, buf);
 849   if (status == REG_VALID)
 850     *val = extract_signed_integer
 851       (buf, regcache->descr->sizeof_register[regnum],
 852        gdbarch_byte_order (regcache->descr->gdbarch));
 853   else
 854     *val = 0;
 855   return status;
 856 }
 857
 858 enum register_status
 859 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
 860                                ULONGEST *val)
 861 {
 862   enum register_status status;
 863   gdb_byte *buf;
 864
 865   gdb_assert (regcache != NULL);
 866   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
 867   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 868   status = regcache_cooked_read (regcache, regnum, buf);
 869   if (status == REG_VALID)
 870     *val = extract_unsigned_integer
 871       (buf, regcache->descr->sizeof_register[regnum],
 872        gdbarch_byte_order (regcache->descr->gdbarch));
 873   else
 874     *val = 0;
 875   return status;
 876 }
 877
 878 void
 879 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
 880                               LONGEST val)
 881 {
 882   gdb_byte *buf;
 883
 884   gdb_assert (regcache != NULL);
 885   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 886   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 887   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
 888                         gdbarch_byte_order (regcache->descr->gdbarch), val);
 889   regcache_cooked_write (regcache, regnum, buf);
 890 }
 891
 892 void
 893 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
 894                                 ULONGEST val)
 895 {
 896   gdb_byte *buf;
 897
 898   gdb_assert (regcache != NULL);
 899   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
 900   buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
 901   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
 902                           gdbarch_byte_order (regcache->descr->gdbarch), val);
 903   regcache_cooked_write (regcache, regnum, buf);
 904 }
 905
 906 /* See regcache.h.  */
 907
 908 void
 909 regcache_raw_set_cached_value (struct regcache *regcache, int regnum,
 910                                const gdb_byte *buf)
 911 {
 912   memcpy (register_buffer (regcache, regnum), buf,
 913           regcache->descr->sizeof_register[regnum]);
 914   regcache->register_status[regnum] = REG_VALID;
 915 }
 916
 917 void
 918 regcache_raw_write (struct regcache *regcache, int regnum,
 919                     const gdb_byte *buf)
 920 {
 921   struct cleanup *chain_before_save_inferior;
 922   struct cleanup *chain_before_invalidate_register;
 923
 924   gdb_assert (regcache != NULL && buf != NULL);
 925   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 926   gdb_assert (!regcache->readonly_p);
 927
 928   /* On the sparc, writing %g0 is a no-op, so we don't even want to
 929      change the registers array if something writes to this register.  */
 930   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
 931     return;
 932
 933   /* If we have a valid copy of the register, and new value == old
 934      value, then don't bother doing the actual store.  */
 935   if (regcache_register_status (regcache, regnum) == REG_VALID
 936       && (memcmp (register_buffer (regcache, regnum), buf,
 937                   regcache->descr->sizeof_register[regnum]) == 0))
 938     return;
 939
 940   chain_before_save_inferior = save_inferior_ptid ();
 941   inferior_ptid = regcache->ptid;
 942
 943   target_prepare_to_store (regcache);
 944   regcache_raw_set_cached_value (regcache, regnum, buf);
 945
 946   /* Register a cleanup function for invalidating the register after it is
 947      written, in case of a failure.  */
 948   chain_before_invalidate_register
 949     = make_cleanup_regcache_invalidate (regcache, regnum);
 950
 951   target_store_registers (regcache, regnum);
 952
 953   /* The target did not throw an error so we can discard invalidating the
 954      register and restore the cleanup chain to what it was.  */
 955   discard_cleanups (chain_before_invalidate_register);
 956
 957   do_cleanups (chain_before_save_inferior);
 958 }
 959
 960 void
 961 regcache_cooked_write (struct regcache *regcache, int regnum,
 962                        const gdb_byte *buf)
 963 {
 964   gdb_assert (regnum >= 0);
 965   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
 966   if (regnum < regcache->descr->nr_raw_registers)
 967     regcache_raw_write (regcache, regnum, buf);
 968   else
 969     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
 970                                    regnum, buf);
 971 }
 972
 973 /* Perform a partial register transfer using a read, modify, write
 974    operation.  */
 975
 976 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
 977                                     void *buf);
 978 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
 979                                      const void *buf);
 980
 981 static enum register_status
 982 regcache_xfer_part (struct regcache *regcache, int regnum,
 983                     int offset, int len, void *in, const void *out,
 984                     enum register_status (*read) (struct regcache *regcache,
 985                                                   int regnum,
 986                                                   gdb_byte *buf),
 987                     void (*write) (struct regcache *regcache, int regnum,
 988                                    const gdb_byte *buf))
 989 {
 990   struct regcache_descr *descr = regcache->descr;
 991   gdb_byte reg[MAX_REGISTER_SIZE];
 992
 993   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
 994   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
 995   /* Something to do?  */
 996   if (offset + len == 0)
 997     return REG_VALID;
 998   /* Read (when needed) ...  */
 999   if (in != NULL
1000       || offset > 0
1001       || offset + len < descr->sizeof_register[regnum])
1002     {
1003       enum register_status status;
1004
1005       gdb_assert (read != NULL);
1006       status = read (regcache, regnum, reg);
1007       if (status != REG_VALID)
1008         return status;
1009     }
1010   /* ... modify ...  */
1011   if (in != NULL)
1012     memcpy (in, reg + offset, len);
1013   if (out != NULL)
1014     memcpy (reg + offset, out, len);
1015   /* ... write (when needed).  */
1016   if (out != NULL)
1017     {
1018       gdb_assert (write != NULL);
1019       write (regcache, regnum, reg);
1020     }
1021
1022   return REG_VALID;
1023 }
1024
1025 enum register_status
1026 regcache_raw_read_part (struct regcache *regcache, int regnum,
1027                         int offset, int len, gdb_byte *buf)
1028 {
1029   struct regcache_descr *descr = regcache->descr;
1030
1031   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1032   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1033                              regcache_raw_read, regcache_raw_write);
1034 }
1035
1036 void
1037 regcache_raw_write_part (struct regcache *regcache, int regnum,
1038                          int offset, int len, const gdb_byte *buf)
1039 {
1040   struct regcache_descr *descr = regcache->descr;
1041
1042   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1043   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1044                       regcache_raw_read, regcache_raw_write);
1045 }
1046
1047 enum register_status
1048 regcache_cooked_read_part (struct regcache *regcache, int regnum,
1049                            int offset, int len, gdb_byte *buf)
1050 {
1051   struct regcache_descr *descr = regcache->descr;
1052
1053   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1054   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1055                              regcache_cooked_read, regcache_cooked_write);
1056 }
1057
1058 void
1059 regcache_cooked_write_part (struct regcache *regcache, int regnum,
1060                             int offset, int len, const gdb_byte *buf)
1061 {
1062   struct regcache_descr *descr = regcache->descr;
1063
1064   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1065   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1066                       regcache_cooked_read, regcache_cooked_write);
1067 }
1068
1069 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
1070
1071 void
1072 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1073 {
1074   void *regbuf;
1075   size_t size;
1076
1077   gdb_assert (regcache != NULL);
1078   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1079   gdb_assert (!regcache->readonly_p);
1080
1081   regbuf = register_buffer (regcache, regnum);
1082   size = regcache->descr->sizeof_register[regnum];
1083
1084   if (buf)
1085     {
1086       memcpy (regbuf, buf, size);
1087       regcache->register_status[regnum] = REG_VALID;
1088     }
1089   else
1090     {
1091       /* This memset not strictly necessary, but better than garbage
1092          in case the register value manages to escape somewhere (due
1093          to a bug, no less).  */
1094       memset (regbuf, 0, size);
1095       regcache->register_status[regnum] = REG_UNAVAILABLE;
1096     }
1097 }
1098
1099 /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
1100
1101 void
1102 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1103 {
1104   const void *regbuf;
1105   size_t size;
1106
1107   gdb_assert (regcache != NULL && buf != NULL);
1108   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1109
1110   regbuf = register_buffer (regcache, regnum);
1111   size = regcache->descr->sizeof_register[regnum];
1112   memcpy (buf, regbuf, size);
1113 }
1114
1115 /* Transfer a single or all registers belonging to a certain register
1116    set to or from a buffer.  This is the main worker function for
1117    regcache_supply_regset and regcache_collect_regset.  */
1118
1119 static void
1120 regcache_transfer_regset (const struct regset *regset,
1121                           const struct regcache *regcache,
1122                           struct regcache *out_regcache,
1123                           int regnum, const void *in_buf,
1124                           void *out_buf, size_t size)
1125 {
1126   const struct regcache_map_entry *map;
1127   int offs = 0, count;
1128
1129   for (map = (const struct regcache_map_entry *) regset->regmap;
1130        (count = map->count) != 0;
1131        map++)
1132     {
1133       int regno = map->regno;
1134       int slot_size = map->size;
1135
1136       if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
1137         slot_size = regcache->descr->sizeof_register[regno];
1138
1139       if (regno == REGCACHE_MAP_SKIP
1140           || (regnum != -1
1141               && (regnum < regno || regnum >= regno + count)))
1142           offs += count * slot_size;
1143
1144       else if (regnum == -1)
1145         for (; count--; regno++, offs += slot_size)
1146           {
1147             if (offs + slot_size > size)
1148               break;
1149
1150             if (out_buf)
1151               regcache_raw_collect (regcache, regno,
1152                                     (gdb_byte *) out_buf + offs);
1153             else
1154               regcache_raw_supply (out_regcache, regno, in_buf
1155                                    ? (const gdb_byte *) in_buf + offs
1156                                    : NULL);
1157           }
1158       else
1159         {
1160           /* Transfer a single register and return.  */
1161           offs += (regnum - regno) * slot_size;
1162           if (offs + slot_size > size)
1163             return;
1164
1165           if (out_buf)
1166             regcache_raw_collect (regcache, regnum,
1167                                   (gdb_byte *) out_buf + offs);
1168           else
1169             regcache_raw_supply (out_regcache, regnum, in_buf
1170                                  ? (const gdb_byte *) in_buf + offs
1171                                  : NULL);
1172           return;
1173         }
1174     }
1175 }
1176
1177 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1178    in REGSET.  If REGNUM is -1, do this for all registers in REGSET.
1179    If BUF is NULL, set the register(s) to "unavailable" status. */
1180
1181 void
1182 regcache_supply_regset (const struct regset *regset,
1183                         struct regcache *regcache,
1184                         int regnum, const void *buf, size_t size)
1185 {
1186   regcache_transfer_regset (regset, regcache, regcache, regnum,
1187                             buf, NULL, size);
1188 }
1189
1190 /* Collect register REGNUM from REGCACHE to BUF, using the register
1191    map in REGSET.  If REGNUM is -1, do this for all registers in
1192    REGSET.  */
1193
1194 void
1195 regcache_collect_regset (const struct regset *regset,
1196                          const struct regcache *regcache,
1197                          int regnum, void *buf, size_t size)
1198 {
1199   regcache_transfer_regset (regset, regcache, NULL, regnum,
1200                             NULL, buf, size);
1201 }
1202
1203
1204 /* Special handling for register PC.  */
1205
1206 CORE_ADDR
1207 regcache_read_pc (struct regcache *regcache)
1208 {
1209   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1210
1211   CORE_ADDR pc_val;
1212
1213   if (gdbarch_read_pc_p (gdbarch))
1214     pc_val = gdbarch_read_pc (gdbarch, regcache);
1215   /* Else use per-frame method on get_current_frame.  */
1216   else if (gdbarch_pc_regnum (gdbarch) >= 0)
1217     {
1218       ULONGEST raw_val;
1219
1220       if (regcache_cooked_read_unsigned (regcache,
1221                                          gdbarch_pc_regnum (gdbarch),
1222                                          &raw_val) == REG_UNAVAILABLE)
1223         throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1224
1225       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1226     }
1227   else
1228     internal_error (__FILE__, __LINE__,
1229                     _("regcache_read_pc: Unable to find PC"));
1230   return pc_val;
1231 }
1232
1233 void
1234 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1235 {
1236   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1237
1238   if (gdbarch_write_pc_p (gdbarch))
1239     gdbarch_write_pc (gdbarch, regcache, pc);
1240   else if (gdbarch_pc_regnum (gdbarch) >= 0)
1241     regcache_cooked_write_unsigned (regcache,
1242                                     gdbarch_pc_regnum (gdbarch), pc);
1243   else
1244     internal_error (__FILE__, __LINE__,
1245                     _("regcache_write_pc: Unable to update PC"));
1246
1247   /* Writing the PC (for instance, from "load") invalidates the
1248      current frame.  */
1249   reinit_frame_cache ();
1250 }
1251
1252
1253 static void
1254 reg_flush_command (char *command, int from_tty)
1255 {
1256   /* Force-flush the register cache.  */
1257   registers_changed ();
1258   if (from_tty)
1259     printf_filtered (_("Register cache flushed.\n"));
1260 }
1261
1262 enum regcache_dump_what
1263 {
1264   regcache_dump_none, regcache_dump_raw,
1265   regcache_dump_cooked, regcache_dump_groups,
1266   regcache_dump_remote
1267 };
1268
1269 static void
1270 regcache_dump (struct regcache *regcache, struct ui_file *file,
1271                enum regcache_dump_what what_to_dump)
1272 {
1273   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1274   struct gdbarch *gdbarch = regcache->descr->gdbarch;
1275   int regnum;
1276   int footnote_nr = 0;
1277   int footnote_register_size = 0;
1278   int footnote_register_offset = 0;
1279   int footnote_register_type_name_null = 0;
1280   long register_offset = 0;
1281   gdb_byte buf[MAX_REGISTER_SIZE];
1282
1283 #if 0
1284   fprintf_unfiltered (file, "nr_raw_registers %d\n",
1285                       regcache->descr->nr_raw_registers);
1286   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1287                       regcache->descr->nr_cooked_registers);
1288   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1289                       regcache->descr->sizeof_raw_registers);
1290   fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
1291                       regcache->descr->sizeof_raw_register_status);
1292   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
1293                       gdbarch_num_regs (gdbarch));
1294   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
1295                       gdbarch_num_pseudo_regs (gdbarch));
1296 #endif
1297
1298   gdb_assert (regcache->descr->nr_cooked_registers
1299               == (gdbarch_num_regs (gdbarch)
1300                   + gdbarch_num_pseudo_regs (gdbarch)));
1301
1302   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1303     {
1304       /* Name.  */
1305       if (regnum < 0)
1306         fprintf_unfiltered (file, " %-10s", "Name");
1307       else
1308         {
1309           const char *p = gdbarch_register_name (gdbarch, regnum);
1310
1311           if (p == NULL)
1312             p = "";
1313           else if (p[0] == '\0')
1314             p = "''";
1315           fprintf_unfiltered (file, " %-10s", p);
1316         }
1317
1318       /* Number.  */
1319       if (regnum < 0)
1320         fprintf_unfiltered (file, " %4s", "Nr");
1321       else
1322         fprintf_unfiltered (file, " %4d", regnum);
1323
1324       /* Relative number.  */
1325       if (regnum < 0)
1326         fprintf_unfiltered (file, " %4s", "Rel");
1327       else if (regnum < gdbarch_num_regs (gdbarch))
1328         fprintf_unfiltered (file, " %4d", regnum);
1329       else
1330         fprintf_unfiltered (file, " %4d",
1331                             (regnum - gdbarch_num_regs (gdbarch)));
1332
1333       /* Offset.  */
1334       if (regnum < 0)
1335         fprintf_unfiltered (file, " %6s  ", "Offset");
1336       else
1337         {
1338           fprintf_unfiltered (file, " %6ld",
1339                               regcache->descr->register_offset[regnum]);
1340           if (register_offset != regcache->descr->register_offset[regnum]
1341               || (regnum > 0
1342                   && (regcache->descr->register_offset[regnum]
1343                       != (regcache->descr->register_offset[regnum - 1]
1344                           + regcache->descr->sizeof_register[regnum - 1])))
1345               )
1346             {
1347               if (!footnote_register_offset)
1348                 footnote_register_offset = ++footnote_nr;
1349               fprintf_unfiltered (file, "*%d", footnote_register_offset);
1350             }
1351           else
1352             fprintf_unfiltered (file, "  ");
1353           register_offset = (regcache->descr->register_offset[regnum]
1354                              + regcache->descr->sizeof_register[regnum]);
1355         }
1356
1357       /* Size.  */
1358       if (regnum < 0)
1359         fprintf_unfiltered (file, " %5s ", "Size");
1360       else
1361         fprintf_unfiltered (file, " %5ld",
1362                             regcache->descr->sizeof_register[regnum]);
1363
1364       /* Type.  */
1365       {
1366         const char *t;
1367
1368         if (regnum < 0)
1369           t = "Type";
1370         else
1371           {
1372             static const char blt[] = "builtin_type";
1373
1374             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1375             if (t == NULL)
1376               {
1377                 char *n;
1378
1379                 if (!footnote_register_type_name_null)
1380                   footnote_register_type_name_null = ++footnote_nr;
1381                 n = xstrprintf ("*%d", footnote_register_type_name_null);
1382                 make_cleanup (xfree, n);
1383                 t = n;
1384               }
1385             /* Chop a leading builtin_type.  */
1386             if (startswith (t, blt))
1387               t += strlen (blt);
1388           }
1389         fprintf_unfiltered (file, " %-15s", t);
1390       }
1391
1392       /* Leading space always present.  */
1393       fprintf_unfiltered (file, " ");
1394
1395       /* Value, raw.  */
1396       if (what_to_dump == regcache_dump_raw)
1397         {
1398           if (regnum < 0)
1399             fprintf_unfiltered (file, "Raw value");
1400           else if (regnum >= regcache->descr->nr_raw_registers)
1401             fprintf_unfiltered (file, "<cooked>");
1402           else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
1403             fprintf_unfiltered (file, "<invalid>");
1404           else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
1405             fprintf_unfiltered (file, "<unavailable>");
1406           else
1407             {
1408               regcache_raw_read (regcache, regnum, buf);
1409               print_hex_chars (file, buf,
1410                                regcache->descr->sizeof_register[regnum],
1411                                gdbarch_byte_order (gdbarch));
1412             }
1413         }
1414
1415       /* Value, cooked.  */
1416       if (what_to_dump == regcache_dump_cooked)
1417         {
1418           if (regnum < 0)
1419             fprintf_unfiltered (file, "Cooked value");
1420           else
1421             {
1422               enum register_status status;
1423
1424               status = regcache_cooked_read (regcache, regnum, buf);
1425               if (status == REG_UNKNOWN)
1426                 fprintf_unfiltered (file, "<invalid>");
1427               else if (status == REG_UNAVAILABLE)
1428                 fprintf_unfiltered (file, "<unavailable>");
1429               else
1430                 print_hex_chars (file, buf,
1431                                  regcache->descr->sizeof_register[regnum],
1432                                  gdbarch_byte_order (gdbarch));
1433             }
1434         }
1435
1436       /* Group members.  */
1437       if (what_to_dump == regcache_dump_groups)
1438         {
1439           if (regnum < 0)
1440             fprintf_unfiltered (file, "Groups");
1441           else
1442             {
1443               const char *sep = "";
1444               struct reggroup *group;
1445
1446               for (group = reggroup_next (gdbarch, NULL);
1447                    group != NULL;
1448                    group = reggroup_next (gdbarch, group))
1449                 {
1450                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1451                     {
1452                       fprintf_unfiltered (file,
1453                                           "%s%s", sep, reggroup_name (group));
1454                       sep = ",";
1455                     }
1456                 }
1457             }
1458         }
1459
1460       /* Remote packet configuration.  */
1461       if (what_to_dump == regcache_dump_remote)
1462         {
1463           if (regnum < 0)
1464             {
1465               fprintf_unfiltered (file, "Rmt Nr  g/G Offset");
1466             }
1467           else if (regnum < regcache->descr->nr_raw_registers)
1468             {
1469               int pnum, poffset;
1470
1471               if (remote_register_number_and_offset (get_regcache_arch (regcache), regnum,
1472                                                      &pnum, &poffset))
1473                 fprintf_unfiltered (file, "%7d %11d", pnum, poffset);
1474             }
1475         }
1476
1477       fprintf_unfiltered (file, "\n");
1478     }
1479
1480   if (footnote_register_size)
1481     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1482                         footnote_register_size);
1483   if (footnote_register_offset)
1484     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1485                         footnote_register_offset);
1486   if (footnote_register_type_name_null)
1487     fprintf_unfiltered (file,
1488                         "*%d: Register type's name NULL.\n",
1489                         footnote_register_type_name_null);
1490   do_cleanups (cleanups);
1491 }
1492
1493 static void
1494 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1495 {
1496   if (args == NULL)
1497     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1498   else
1499     {
1500       struct cleanup *cleanups;
1501       struct ui_file *file = gdb_fopen (args, "w");
1502
1503       if (file == NULL)
1504         perror_with_name (_("maintenance print architecture"));
1505       cleanups = make_cleanup_ui_file_delete (file);
1506       regcache_dump (get_current_regcache (), file, what_to_dump);
1507       do_cleanups (cleanups);
1508     }
1509 }
1510
1511 static void
1512 maintenance_print_registers (char *args, int from_tty)
1513 {
1514   regcache_print (args, regcache_dump_none);
1515 }
1516
1517 static void
1518 maintenance_print_raw_registers (char *args, int from_tty)
1519 {
1520   regcache_print (args, regcache_dump_raw);
1521 }
1522
1523 static void
1524 maintenance_print_cooked_registers (char *args, int from_tty)
1525 {
1526   regcache_print (args, regcache_dump_cooked);
1527 }
1528
1529 static void
1530 maintenance_print_register_groups (char *args, int from_tty)
1531 {
1532   regcache_print (args, regcache_dump_groups);
1533 }
1534
1535 static void
1536 maintenance_print_remote_registers (char *args, int from_tty)
1537 {
1538   regcache_print (args, regcache_dump_remote);
1539 }
1540
1541 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1542
1543 void
1544 _initialize_regcache (void)
1545 {
1546   regcache_descr_handle
1547     = gdbarch_data_register_post_init (init_regcache_descr);
1548
1549   observer_attach_target_changed (regcache_observer_target_changed);
1550   observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1551
1552   add_com ("flushregs", class_maintenance, reg_flush_command,
1553            _("Force gdb to flush its register cache (maintainer command)"));
1554
1555   add_cmd ("registers", class_maintenance, maintenance_print_registers,
1556            _("Print the internal register configuration.\n"
1557              "Takes an optional file parameter."), &maintenanceprintlist);
1558   add_cmd ("raw-registers", class_maintenance,
1559            maintenance_print_raw_registers,
1560            _("Print the internal register configuration "
1561              "including raw values.\n"
1562              "Takes an optional file parameter."), &maintenanceprintlist);
1563   add_cmd ("cooked-registers", class_maintenance,
1564            maintenance_print_cooked_registers,
1565            _("Print the internal register configuration "
1566              "including cooked values.\n"
1567              "Takes an optional file parameter."), &maintenanceprintlist);
1568   add_cmd ("register-groups", class_maintenance,
1569            maintenance_print_register_groups,
1570            _("Print the internal register configuration "
1571              "including each register's group.\n"
1572              "Takes an optional file parameter."),
1573            &maintenanceprintlist);
1574   add_cmd ("remote-registers", class_maintenance,
1575            maintenance_print_remote_registers, _("\
1576 Print the internal register configuration including each register's\n\
1577 remote register number and buffer offset in the g/G packets.\n\
1578 Takes an optional file parameter."),
1579            &maintenanceprintlist);
1580
1581 }