gdb/regcache.c

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