gdb/regcache.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Cache and manage the values of registers for GDB, the GNU debugger.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  32. /*
  33. * DATA STRUCTURE
  34. *
  35. * Here is the actual register cache.
  36. */

  38. /* Per-architecture object describing the layout of a register cache.
  39.    Computed once when the architecture is created.  */

  41. ‌struct gdbarch_data *regcache_descr_handle;

  43. ‌struct regcache_descr
  44. {
  45.   /* The architecture this descriptor belongs to.  */
  46.   struct gdbarch *gdbarch;

  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;

  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;

  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;

  74.   /* Cached table containing the type of each register.  */
  75.   struct type **register_type;
  76. };

  78. static void *
  79. ‌init_regcache_descr (struct gdbarch *gdbarch)
  80. {
  81.   int i;
  82.   struct regcache_descr *descr;
  83.   gdb_assert (gdbarch != NULL);

  85.   /* Create an initial, zero filled, table.  */
  86.   descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
  87.   descr->gdbarch = gdbarch;

  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);

  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);

  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);

  109.   /* Lay out the register cache.

  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.  */

  116.   {
  117.     long offset = 0;

  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;

  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.   }

  144.   return descr;
  145. }

  147. static struct regcache_descr *
  148. ‌regcache_descr (struct gdbarch *gdbarch)
  149. {
  150.   return gdbarch_data (gdbarch, regcache_descr_handle);
  151. }

  153. /* Utility functions returning useful register attributes stored in
  154.    the regcache descr.  */

  156. struct type *
  157. ‌register_type (struct gdbarch *gdbarch, int regnum)
  158. {
  159.   struct regcache_descr *descr = regcache_descr (gdbarch);

  161.   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
  162.   return descr->register_type[regnum];
  163. }

  165. /* Utility functions returning useful register attributes stored in
  166.    the regcache descr.  */

  168. int
  169. ‌register_size (struct gdbarch *gdbarch, int regnum)
  170. {
  171.   struct regcache_descr *descr = regcache_descr (gdbarch);
  172.   int size;

  174.   gdb_assert (regnum >= 0
  175.               && regnum < (gdbarch_num_regs (gdbarch)
  176.                            + gdbarch_num_pseudo_regs (gdbarch)));
  177.   size = descr->sizeof_register[regnum];
  178.   return size;
  179. }

  181. /* The register cache for storing raw register values.  */

  183. ‌struct regcache
  184. {
  185.   struct regcache_descr *descr;

  187.   /* The address space of this register cache (for registers where it
  188.      makes sense, like PC or SP).  */
  189.   struct address_space *aspace;

  191.   /* The register buffers.  A read-only register cache can hold the
  192.      full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
  193.      register cache can only hold [0 .. gdbarch_num_regs).  */
  194.   gdb_byte *registers;
  195.   /* Register cache status.  */
  196.   signed char *register_status;
  197.   /* Is this a read-only cache?  A read-only cache is used for saving
  198.      the target's register state (e.g, across an inferior function
  199.      call or just before forcing a function return).  A read-only
  200.      cache can only be updated via the methods regcache_dup() and
  201.      regcache_cpy().  The actual contents are determined by the
  202.      reggroup_save and reggroup_restore methods.  */
  203.   int readonly_p;
  204.   /* If this is a read-write cache, which thread's registers is
  205.      it connected to?  */
  206.   ptid_t ptid;
  207. };

  209. static struct regcache *
  210. ‌regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
  211.                     int readonly_p)
  212. {
  213.   struct regcache_descr *descr;
  214.   struct regcache *regcache;

  216.   gdb_assert (gdbarch != NULL);
  217.   descr = regcache_descr (gdbarch);
  218.   regcache = XNEW (struct regcache);
  219.   regcache->descr = descr;
  220.   regcache->readonly_p = readonly_p;
  221.   if (readonly_p)
  222.     {
  223.       regcache->registers
  224.         = XCNEWVEC (gdb_byte, descr->sizeof_cooked_registers);
  225.       regcache->register_status
  226.         = XCNEWVEC (signed char, descr->sizeof_cooked_register_status);
  227.     }
  228.   else
  229.     {
  230.       regcache->registers
  231.         = XCNEWVEC (gdb_byte, descr->sizeof_raw_registers);
  232.       regcache->register_status
  233.         = XCNEWVEC (signed char, descr->sizeof_raw_register_status);
  234.     }
  235.   regcache->aspace = aspace;
  236.   regcache->ptid = minus_one_ptid;
  237.   return regcache;
  238. }

  240. struct regcache *
  241. ‌regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
  242. {
  243.   return regcache_xmalloc_1 (gdbarch, aspace, 1);
  244. }

  246. void
  247. ‌regcache_xfree (struct regcache *regcache)
  248. {
  249.   if (regcache == NULL)
  250.     return;
  251.   xfree (regcache->registers);
  252.   xfree (regcache->register_status);
  253.   xfree (regcache);
  254. }

  256. static void
  257. ‌do_regcache_xfree (void *data)
  258. {
  259.   regcache_xfree (data);
  260. }

  262. struct cleanup *
  263. ‌make_cleanup_regcache_xfree (struct regcache *regcache)
  264. {
  265.   return make_cleanup (do_regcache_xfree, regcache);
  266. }

  268. /* Cleanup routines for invalidating a register.  */

  270. ‌struct register_to_invalidate
  271. {
  272.   struct regcache *regcache;
  273.   int regnum;
  274. };

  276. static void
  277. ‌do_regcache_invalidate (void *data)
  278. {
  279.   struct register_to_invalidate *reg = data;

  281.   regcache_invalidate (reg->regcache, reg->regnum);
  282. }

  284. static struct cleanup *
  285. ‌make_cleanup_regcache_invalidate (struct regcache *regcache, int regnum)
  286. {
  287.   struct register_to_invalidate* reg = XNEW (struct register_to_invalidate);

  289.   reg->regcache = regcache;
  290.   reg->regnum = regnum;
  291.   return make_cleanup_dtor (do_regcache_invalidate, (void *) reg, xfree);
  292. }

  294. /* Return REGCACHE's architecture.  */

  296. struct gdbarch *
  297. ‌get_regcache_arch (const struct regcache *regcache)
  298. {
  299.   return regcache->descr->gdbarch;
  300. }

  302. struct address_space *
  303. ‌get_regcache_aspace (const struct regcache *regcache)
  304. {
  305.   return regcache->aspace;
  306. }

  308. /* Return  a pointer to register REGNUM's buffer cache.  */

  310. static gdb_byte *
  311. ‌register_buffer (const struct regcache *regcache, int regnum)
  312. {
  313.   return regcache->registers + regcache->descr->register_offset[regnum];
  314. }

  316. void
  317. ‌regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
  318.                void *src)
  319. {
  320.   struct gdbarch *gdbarch = dst->descr->gdbarch;
  321.   gdb_byte buf[MAX_REGISTER_SIZE];
  322.   int regnum;

  324.   /* The DST should be `read-only', if it wasn't then the save would
  325.      end up trying to write the register values back out to the
  326.      target.  */
  327.   gdb_assert (dst->readonly_p);
  328.   /* Clear the dest.  */
  329.   memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
  330.   memset (dst->register_status, 0,
  331.           dst->descr->sizeof_cooked_register_status);
  332.   /* Copy over any registers (identified by their membership in the
  333.      save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
  334.      gdbarch_num_pseudo_regs) range is checked since some architectures need
  335.      to save/restore `cooked' registers that live in memory.  */
  336.   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
  337.     {
  338.       if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
  339.         {
  340.           enum register_status status = cooked_read (src, regnum, buf);

  342.           if (status == REG_VALID)
  343.             memcpy (register_buffer (dst, regnum), buf,
  344.                     register_size (gdbarch, regnum));
  345.           else
  346.             {
  347.               gdb_assert (status != REG_UNKNOWN);

  349.               memset (register_buffer (dst, regnum), 0,
  350.                       register_size (gdbarch, regnum));
  351.             }
  352.           dst->register_status[regnum] = status;
  353.         }
  354.     }
  355. }

  357. static void
  358. ‌regcache_restore (struct regcache *dst,
  359.                   regcache_cooked_read_ftype *cooked_read,
  360.                   void *cooked_read_context)
  361. {
  362.   struct gdbarch *gdbarch = dst->descr->gdbarch;
  363.   gdb_byte buf[MAX_REGISTER_SIZE];
  364.   int regnum;

  366.   /* The dst had better not be read-only.  If it is, the `restore'
  367.      doesn't make much sense.  */
  368.   gdb_assert (!dst->readonly_p);
  369.   /* Copy over any registers, being careful to only restore those that
  370.      were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
  371.      + gdbarch_num_pseudo_regs) range is checked since some architectures need
  372.      to save/restore `cooked' registers that live in memory.  */
  373.   for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
  374.     {
  375.       if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
  376.         {
  377.           enum register_status status;

  379.           status = cooked_read (cooked_read_context, regnum, buf);
  380.           if (status == REG_VALID)
  381.             regcache_cooked_write (dst, regnum, buf);
  382.         }
  383.     }
  384. }

  386. static enum register_status
  387. ‌do_cooked_read (void *src, int regnum, gdb_byte *buf)
  388. {
  389.   struct regcache *regcache = src;

  391.   return regcache_cooked_read (regcache, regnum, buf);
  392. }

  394. void
  395. ‌regcache_cpy (struct regcache *dst, struct regcache *src)
  396. {
  397.   gdb_assert (src != NULL && dst != NULL);
  398.   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
  399.   gdb_assert (src != dst);
  400.   gdb_assert (src->readonly_p || dst->readonly_p);

  402.   if (!src->readonly_p)
  403.     regcache_save (dst, do_cooked_read, src);
  404.   else if (!dst->readonly_p)
  405.     regcache_restore (dst, do_cooked_read, src);
  406.   else
  407.     regcache_cpy_no_passthrough (dst, src);
  408. }

  410. void
  411. ‌regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
  412. {
  413.   gdb_assert (src != NULL && dst != NULL);
  414.   gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
  415.   /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
  416.      move of data into a thread's regcache.  Doing this would be silly
  417.      - it would mean that regcache->register_status would be
  418.      completely invalid.  */
  419.   gdb_assert (dst->readonly_p && src->readonly_p);

  421.   memcpy (dst->registers, src->registers,
  422.           dst->descr->sizeof_cooked_registers);
  423.   memcpy (dst->register_status, src->register_status,
  424.           dst->descr->sizeof_cooked_register_status);
  425. }

  427. struct regcache *
  428. ‌regcache_dup (struct regcache *src)
  429. {
  430.   struct regcache *newbuf;

  432.   newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
  433.   regcache_cpy (newbuf, src);
  434.   return newbuf;
  435. }

  437. enum register_status
  438. ‌regcache_register_status (const struct regcache *regcache, int regnum)
  439. {
  440.   gdb_assert (regcache != NULL);
  441.   gdb_assert (regnum >= 0);
  442.   if (regcache->readonly_p)
  443.     gdb_assert (regnum < regcache->descr->nr_cooked_registers);
  444.   else
  445.     gdb_assert (regnum < regcache->descr->nr_raw_registers);

  447.   return regcache->register_status[regnum];
  448. }

  450. void
  451. ‌regcache_invalidate (struct regcache *regcache, int regnum)
  452. {
  453.   gdb_assert (regcache != NULL);
  454.   gdb_assert (regnum >= 0);
  455.   gdb_assert (!regcache->readonly_p);
  456.   gdb_assert (regnum < regcache->descr->nr_raw_registers);
  457.   regcache->register_status[regnum] = REG_UNKNOWN;
  458. }


  461. /* Global structure containing the current regcache.  */

  463. /* NOTE: this is a write-through cache.  There is no "dirty" bit for
  464.    recording if the register values have been changed (eg. by the
  465.    user).  Therefore all registers must be written back to the
  466.    target when appropriate.  */

  468. ‌struct regcache_list
  469. {
  470.   struct regcache *regcache;
  471.   struct regcache_list *next;
  472. };

  474. ‌static struct regcache_list *current_regcache;

  476. struct regcache *
  477. ‌get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
  478.                                  struct address_space *aspace)
  479. {
  480.   struct regcache_list *list;
  481.   struct regcache *new_regcache;

  483.   for (list = current_regcache; list; list = list->next)
  484.     if (ptid_equal (list->regcache->ptid, ptid)
  485.         && get_regcache_arch (list->regcache) == gdbarch)
  486.       return list->regcache;

  488.   new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
  489.   new_regcache->ptid = ptid;

  491.   list = xmalloc (sizeof (struct regcache_list));
  492.   list->regcache = new_regcache;
  493.   list->next = current_regcache;
  494.   current_regcache = list;

  496.   return new_regcache;
  497. }

  499. struct regcache *
  500. ‌get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
  501. {
  502.   struct address_space *aspace;

  504.   /* For the benefit of "maint print registers" & co when debugging an
  505.      executable, allow dumping the regcache even when there is no
  506.      thread selected (target_thread_address_space internal-errors if
  507.      no address space is found).  Note that normal user commands will
  508.      fail higher up on the call stack due to no
  509.      target_has_registers.  */
  510.   aspace = (ptid_equal (null_ptid, ptid)
  511.             ? NULL
  512.             : target_thread_address_space (ptid));

  514.   return get_thread_arch_aspace_regcache  (ptid, gdbarch, aspace);
  515. }

  517. ‌static ptid_t current_thread_ptid;
  518. ‌static struct gdbarch *current_thread_arch;

  520. struct regcache *
  521. ‌get_thread_regcache (ptid_t ptid)
  522. {
  523.   if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
  524.     {
  525.       current_thread_ptid = ptid;
  526.       current_thread_arch = target_thread_architecture (ptid);
  527.     }

  529.   return get_thread_arch_regcache (ptid, current_thread_arch);
  530. }

  532. struct regcache *
  533. ‌get_current_regcache (void)
  534. {
  535.   return get_thread_regcache (inferior_ptid);
  536. }

  538. /* See common/common-regcache.h.  */

  540. struct regcache *
  541. ‌get_thread_regcache_for_ptid (ptid_t ptid)
  542. {
  543.   return get_thread_regcache (ptid);
  544. }

  546. /* Observer for the target_changed event.  */

  548. static void
  549. ‌regcache_observer_target_changed (struct target_ops *target)
  550. {
  551.   registers_changed ();
  552. }

  554. /* Update global variables old ptids to hold NEW_PTID if they were
  555.    holding OLD_PTID.  */
  556. static void
  557. ‌regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
  558. {
  559.   struct regcache_list *list;

  561.   for (list = current_regcache; list; list = list->next)
  562.     if (ptid_equal (list->regcache->ptid, old_ptid))
  563.       list->regcache->ptid = new_ptid;
  564. }

  566. /* Low level examining and depositing of registers.

  568.    The caller is responsible for making sure that the inferior is
  569.    stopped before calling the fetching routines, or it will get
  570.    garbage.  (a change from GDB version 3, in which the caller got the
  571.    value from the last stop).  */

  573. /* REGISTERS_CHANGED ()

  575.    Indicate that registers may have changed, so invalidate the cache.  */

  577. void
  578. ‌registers_changed_ptid (ptid_t ptid)
  579. {
  580.   struct regcache_list *list, **list_link;

  582.   list = current_regcache;
  583.   list_link = &current_regcache;
  584.   while (list)
  585.     {
  586.       if (ptid_match (list->regcache->ptid, ptid))
  587.         {
  588.           struct regcache_list *dead = list;

  590.           *list_link = list->next;
  591.           regcache_xfree (list->regcache);
  592.           list = *list_link;
  593.           xfree (dead);
  594.           continue;
  595.         }

  597.       list_link = &list->next;
  598.       list = *list_link;
  599.     }

  601.   if (ptid_match (current_thread_ptid, ptid))
  602.     {
  603.       current_thread_ptid = null_ptid;
  604.       current_thread_arch = NULL;
  605.     }

  607.   if (ptid_match (inferior_ptid, ptid))
  608.     {
  609.       /* We just deleted the regcache of the current thread.  Need to
  610.          forget about any frames we have cached, too.  */
  611.       reinit_frame_cache ();
  612.     }
  613. }

  615. void
  616. ‌registers_changed (void)
  617. {
  618.   registers_changed_ptid (minus_one_ptid);

  620.   /* Force cleanup of any alloca areas if using C alloca instead of
  621.      a builtin alloca.  This particular call is used to clean up
  622.      areas allocated by low level target code which may build up
  623.      during lengthy interactions between gdb and the target before
  624.      gdb gives control to the user (ie watchpoints).  */
  625.   alloca (0);
  626. }

  628. enum register_status
  629. ‌regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
  630. {
  631.   gdb_assert (regcache != NULL && buf != NULL);
  632.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
  633.   /* Make certain that the register cache is up-to-date with respect
  634.      to the current thread.  This switching shouldn't be necessary
  635.      only there is still only one target side register cache.  Sigh!
  636.      On the bright side, at least there is a regcache object.  */
  637.   if (!regcache->readonly_p
  638.       && regcache_register_status (regcache, regnum) == REG_UNKNOWN)
  639.     {
  640.       struct cleanup *old_chain = save_inferior_ptid ();

  642.       inferior_ptid = regcache->ptid;
  643.       target_fetch_registers (regcache, regnum);
  644.       do_cleanups (old_chain);

  646.       /* A number of targets can't access the whole set of raw
  647.          registers (because the debug API provides no means to get at
  648.          them).  */
  649.       if (regcache->register_status[regnum] == REG_UNKNOWN)
  650.         regcache->register_status[regnum] = REG_UNAVAILABLE;
  651.     }

  653.   if (regcache->register_status[regnum] != REG_VALID)
  654.     memset (buf, 0, regcache->descr->sizeof_register[regnum]);
  655.   else
  656.     memcpy (buf, register_buffer (regcache, regnum),
  657.             regcache->descr->sizeof_register[regnum]);

  659.   return regcache->register_status[regnum];
  660. }

  662. enum register_status
  663. ‌regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
  664. {
  665.   gdb_byte *buf;
  666.   enum register_status status;

  668.   gdb_assert (regcache != NULL);
  669.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
  670.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  671.   status = regcache_raw_read (regcache, regnum, buf);
  672.   if (status == REG_VALID)
  673.     *val = extract_signed_integer
  674.       (buf, regcache->descr->sizeof_register[regnum],
  675.        gdbarch_byte_order (regcache->descr->gdbarch));
  676.   else
  677.     *val = 0;
  678.   return status;
  679. }

  681. enum register_status
  682. ‌regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
  683.                             ULONGEST *val)
  684. {
  685.   gdb_byte *buf;
  686.   enum register_status status;

  688.   gdb_assert (regcache != NULL);
  689.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
  690.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  691.   status = regcache_raw_read (regcache, regnum, buf);
  692.   if (status == REG_VALID)
  693.     *val = extract_unsigned_integer
  694.       (buf, regcache->descr->sizeof_register[regnum],
  695.        gdbarch_byte_order (regcache->descr->gdbarch));
  696.   else
  697.     *val = 0;
  698.   return status;
  699. }

  701. void
  702. ‌regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
  703. {
  704.   void *buf;

  706.   gdb_assert (regcache != NULL);
  707.   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
  708.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  709.   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
  710.                         gdbarch_byte_order (regcache->descr->gdbarch), val);
  711.   regcache_raw_write (regcache, regnum, buf);
  712. }

  714. void
  715. ‌regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
  716.                              ULONGEST val)
  717. {
  718.   void *buf;

  720.   gdb_assert (regcache != NULL);
  721.   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
  722.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  723.   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
  724.                           gdbarch_byte_order (regcache->descr->gdbarch), val);
  725.   regcache_raw_write (regcache, regnum, buf);
  726. }

  728. enum register_status
  729. ‌regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
  730. {
  731.   gdb_assert (regnum >= 0);
  732.   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
  733.   if (regnum < regcache->descr->nr_raw_registers)
  734.     return regcache_raw_read (regcache, regnum, buf);
  735.   else if (regcache->readonly_p
  736.            && regcache->register_status[regnum] != REG_UNKNOWN)
  737.     {
  738.       /* Read-only register cache, perhaps the cooked value was
  739.          cached?  */
  740.       if (regcache->register_status[regnum] == REG_VALID)
  741.         memcpy (buf, register_buffer (regcache, regnum),
  742.                 regcache->descr->sizeof_register[regnum]);
  743.       else
  744.         memset (buf, 0, regcache->descr->sizeof_register[regnum]);

  746.       return regcache->register_status[regnum];
  747.     }
  748.   else if (gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
  749.     {
  750.       struct value *mark, *computed;
  751.       enum register_status result = REG_VALID;

  753.       mark = value_mark ();

  755.       computed = gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
  756.                                                      regcache, regnum);
  757.       if (value_entirely_available (computed))
  758.         memcpy (buf, value_contents_raw (computed),
  759.                 regcache->descr->sizeof_register[regnum]);
  760.       else
  761.         {
  762.           memset (buf, 0, regcache->descr->sizeof_register[regnum]);
  763.           result = REG_UNAVAILABLE;
  764.         }

  766.       value_free_to_mark (mark);

  768.       return result;
  769.     }
  770.   else
  771.     return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
  772.                                          regnum, buf);
  773. }

  775. struct value *
  776. ‌regcache_cooked_read_value (struct regcache *regcache, int regnum)
  777. {
  778.   gdb_assert (regnum >= 0);
  779.   gdb_assert (regnum < regcache->descr->nr_cooked_registers);

  781.   if (regnum < regcache->descr->nr_raw_registers
  782.       || (regcache->readonly_p
  783.           && regcache->register_status[regnum] != REG_UNKNOWN)
  784.       || !gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
  785.     {
  786.       struct value *result;

  788.       result = allocate_value (register_type (regcache->descr->gdbarch,
  789.                                               regnum));
  790.       VALUE_LVAL (result) = lval_register;
  791.       VALUE_REGNUM (result) = regnum;

  793.       /* It is more efficient in general to do this delegation in this
  794.          direction than in the other one, even though the value-based
  795.          API is preferred.  */
  796.       if (regcache_cooked_read (regcache, regnum,
  797.                                 value_contents_raw (result)) == REG_UNAVAILABLE)
  798.         mark_value_bytes_unavailable (result, 0,
  799.                                       TYPE_LENGTH (value_type (result)));

  801.       return result;
  802.     }
  803.   else
  804.     return gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
  805.                                                regcache, regnum);
  806. }

  808. enum register_status
  809. ‌regcache_cooked_read_signed (struct regcache *regcache, int regnum,
  810.                              LONGEST *val)
  811. {
  812.   enum register_status status;
  813.   gdb_byte *buf;

  815.   gdb_assert (regcache != NULL);
  816.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
  817.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  818.   status = regcache_cooked_read (regcache, regnum, buf);
  819.   if (status == REG_VALID)
  820.     *val = extract_signed_integer
  821.       (buf, regcache->descr->sizeof_register[regnum],
  822.        gdbarch_byte_order (regcache->descr->gdbarch));
  823.   else
  824.     *val = 0;
  825.   return status;
  826. }

  828. enum register_status
  829. ‌regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
  830.                                ULONGEST *val)
  831. {
  832.   enum register_status status;
  833.   gdb_byte *buf;

  835.   gdb_assert (regcache != NULL);
  836.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
  837.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  838.   status = regcache_cooked_read (regcache, regnum, buf);
  839.   if (status == REG_VALID)
  840.     *val = extract_unsigned_integer
  841.       (buf, regcache->descr->sizeof_register[regnum],
  842.        gdbarch_byte_order (regcache->descr->gdbarch));
  843.   else
  844.     *val = 0;
  845.   return status;
  846. }

  848. void
  849. ‌regcache_cooked_write_signed (struct regcache *regcache, int regnum,
  850.                               LONGEST val)
  851. {
  852.   void *buf;

  854.   gdb_assert (regcache != NULL);
  855.   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
  856.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  857.   store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
  858.                         gdbarch_byte_order (regcache->descr->gdbarch), val);
  859.   regcache_cooked_write (regcache, regnum, buf);
  860. }

  862. void
  863. ‌regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
  864.                                 ULONGEST val)
  865. {
  866.   void *buf;

  868.   gdb_assert (regcache != NULL);
  869.   gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
  870.   buf = alloca (regcache->descr->sizeof_register[regnum]);
  871.   store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
  872.                           gdbarch_byte_order (regcache->descr->gdbarch), val);
  873.   regcache_cooked_write (regcache, regnum, buf);
  874. }

  876. void
  877. ‌regcache_raw_write (struct regcache *regcache, int regnum,
  878.                     const gdb_byte *buf)
  879. {
  880.   struct cleanup *chain_before_save_inferior;
  881.   struct cleanup *chain_before_invalidate_register;

  883.   gdb_assert (regcache != NULL && buf != NULL);
  884.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
  885.   gdb_assert (!regcache->readonly_p);

  887.   /* On the sparc, writing %g0 is a no-op, so we don't even want to
  888.      change the registers array if something writes to this register.  */
  889.   if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
  890.     return;

  892.   /* If we have a valid copy of the register, and new value == old
  893.      value, then don't bother doing the actual store.  */
  894.   if (regcache_register_status (regcache, regnum) == REG_VALID
  895.       && (memcmp (register_buffer (regcache, regnum), buf,
  896.                   regcache->descr->sizeof_register[regnum]) == 0))
  897.     return;

  899.   chain_before_save_inferior = save_inferior_ptid ();
  900.   inferior_ptid = regcache->ptid;

  902.   target_prepare_to_store (regcache);
  903.   memcpy (register_buffer (regcache, regnum), buf,
  904.           regcache->descr->sizeof_register[regnum]);
  905.   regcache->register_status[regnum] = REG_VALID;

  907.   /* Register a cleanup function for invalidating the register after it is
  908.      written, in case of a failure.  */
  909.   chain_before_invalidate_register
  910.     = make_cleanup_regcache_invalidate (regcache, regnum);

  912.   target_store_registers (regcache, regnum);

  914.   /* The target did not throw an error so we can discard invalidating the
  915.      register and restore the cleanup chain to what it was.  */
  916.   discard_cleanups (chain_before_invalidate_register);

  918.   do_cleanups (chain_before_save_inferior);
  919. }

  921. void
  922. ‌regcache_cooked_write (struct regcache *regcache, int regnum,
  923.                        const gdb_byte *buf)
  924. {
  925.   gdb_assert (regnum >= 0);
  926.   gdb_assert (regnum < regcache->descr->nr_cooked_registers);
  927.   if (regnum < regcache->descr->nr_raw_registers)
  928.     regcache_raw_write (regcache, regnum, buf);
  929.   else
  930.     gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
  931.                                    regnum, buf);
  932. }

  934. /* Perform a partial register transfer using a read, modify, write
  935.    operation.  */

  937. ‌typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
  938.                                     void *buf);
  939. ‌typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
  940.                                      const void *buf);

  942. static enum register_status
  943. ‌regcache_xfer_part (struct regcache *regcache, int regnum,
  944.                     int offset, int len, void *in, const void *out,
  945.                     enum register_status (*read) (struct regcache *regcache,
  946.                                                   int regnum,
  947.                                                   gdb_byte *buf),
  948.                     void (*write) (struct regcache *regcache, int regnum,
  949.                                    const gdb_byte *buf))
  950. {
  951.   struct regcache_descr *descr = regcache->descr;
  952.   gdb_byte reg[MAX_REGISTER_SIZE];

  954.   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
  955.   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
  956.   /* Something to do?  */
  957.   if (offset + len == 0)
  958.     return REG_VALID;
  959.   /* Read (when needed) ...  */
  960.   if (in != NULL
  961.       || offset > 0
  962.       || offset + len < descr->sizeof_register[regnum])
  963.     {
  964.       enum register_status status;

  966.       gdb_assert (read != NULL);
  967.       status = read (regcache, regnum, reg);
  968.       if (status != REG_VALID)
  969.         return status;
  970.     }
  971.   /* ... modify ...  */
  972.   if (in != NULL)
  973.     memcpy (in, reg + offset, len);
  974.   if (out != NULL)
  975.     memcpy (reg + offset, out, len);
  976.   /* ... write (when needed).  */
  977.   if (out != NULL)
  978.     {
  979.       gdb_assert (write != NULL);
  980.       write (regcache, regnum, reg);
  981.     }

  983.   return REG_VALID;
  984. }

  986. enum register_status
  987. ‌regcache_raw_read_part (struct regcache *regcache, int regnum,
  988.                         int offset, int len, gdb_byte *buf)
  989. {
  990.   struct regcache_descr *descr = regcache->descr;

  992.   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
  993.   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
  994.                              regcache_raw_read, regcache_raw_write);
  995. }

  997. void
  998. ‌regcache_raw_write_part (struct regcache *regcache, int regnum,
  999.                          int offset, int len, const gdb_byte *buf)
  1000. {
  1001.   struct regcache_descr *descr = regcache->descr;

  1003.   gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
  1004.   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
  1005.                       regcache_raw_read, regcache_raw_write);
  1006. }

  1008. enum register_status
  1009. ‌regcache_cooked_read_part (struct regcache *regcache, int regnum,
  1010.                            int offset, int len, gdb_byte *buf)
  1011. {
  1012.   struct regcache_descr *descr = regcache->descr;

  1014.   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
  1015.   return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
  1016.                              regcache_cooked_read, regcache_cooked_write);
  1017. }

  1019. void
  1020. ‌regcache_cooked_write_part (struct regcache *regcache, int regnum,
  1021.                             int offset, int len, const gdb_byte *buf)
  1022. {
  1023.   struct regcache_descr *descr = regcache->descr;

  1025.   gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
  1026.   regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
  1027.                       regcache_cooked_read, regcache_cooked_write);
  1028. }

  1030. /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */

  1032. void
  1033. ‌regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
  1034. {
  1035.   void *regbuf;
  1036.   size_t size;

  1038.   gdb_assert (regcache != NULL);
  1039.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
  1040.   gdb_assert (!regcache->readonly_p);

  1042.   regbuf = register_buffer (regcache, regnum);
  1043.   size = regcache->descr->sizeof_register[regnum];

  1045.   if (buf)
  1046.     {
  1047.       memcpy (regbuf, buf, size);
  1048.       regcache->register_status[regnum] = REG_VALID;
  1049.     }
  1050.   else
  1051.     {
  1052.       /* This memset not strictly necessary, but better than garbage
  1053.          in case the register value manages to escape somewhere (due
  1054.          to a bug, no less).  */
  1055.       memset (regbuf, 0, size);
  1056.       regcache->register_status[regnum] = REG_UNAVAILABLE;
  1057.     }
  1058. }

  1060. /* Collect register REGNUM from REGCACHE and store its contents in BUF.  */

  1062. void
  1063. ‌regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
  1064. {
  1065.   const void *regbuf;
  1066.   size_t size;

  1068.   gdb_assert (regcache != NULL && buf != NULL);
  1069.   gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);

  1071.   regbuf = register_buffer (regcache, regnum);
  1072.   size = regcache->descr->sizeof_register[regnum];
  1073.   memcpy (buf, regbuf, size);
  1074. }

  1076. /* Transfer a single or all registers belonging to a certain register
  1077.    set to or from a buffer.  This is the main worker function for
  1078.    regcache_supply_regset and regcache_collect_regset.  */

  1080. static void
  1081. ‌regcache_transfer_regset (const struct regset *regset,
  1082.                           const struct regcache *regcache,
  1083.                           struct regcache *out_regcache,
  1084.                           int regnum, const void *in_buf,
  1085.                           void *out_buf, size_t size)
  1086. {
  1087.   const struct regcache_map_entry *map;
  1088.   int offs = 0, count;

  1090.   for (map = regset->regmap; (count = map->count) != 0; map++)
  1091.     {
  1092.       int regno = map->regno;
  1093.       int slot_size = map->size;

  1095.       if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
  1096.         slot_size = regcache->descr->sizeof_register[regno];

  1098.       if (regno == REGCACHE_MAP_SKIP
  1099.           || (regnum != -1
  1100.               && (regnum < regno || regnum >= regno + count)))
  1101.           offs += count * slot_size;

  1103.       else if (regnum == -1)
  1104.         for (; count--; regno++, offs += slot_size)
  1105.           {
  1106.             if (offs + slot_size > size)
  1107.               break;

  1109.             if (out_buf)
  1110.               regcache_raw_collect (regcache, regno,
  1111.                                     (gdb_byte *) out_buf + offs);
  1112.             else
  1113.               regcache_raw_supply (out_regcache, regno, in_buf
  1114.                                    ? (const gdb_byte *) in_buf + offs
  1115.                                    : NULL);
  1116.           }
  1117.       else
  1118.         {
  1119.           /* Transfer a single register and return.  */
  1120.           offs += (regnum - regno) * slot_size;
  1121.           if (offs + slot_size > size)
  1122.             return;

  1124.           if (out_buf)
  1125.             regcache_raw_collect (regcache, regnum,
  1126.                                   (gdb_byte *) out_buf + offs);
  1127.           else
  1128.             regcache_raw_supply (out_regcache, regnum, in_buf
  1129.                                  ? (const gdb_byte *) in_buf + offs
  1130.                                  : NULL);
  1131.           return;
  1132.         }
  1133.     }
  1134. }

  1136. /* Supply register REGNUM from BUF to REGCACHE, using the register map
  1137.    in REGSET.  If REGNUM is -1, do this for all registers in REGSET.
  1138.    If BUF is NULL, set the register(s) to "unavailable" status. */

  1140. void
  1141. ‌regcache_supply_regset (const struct regset *regset,
  1142.                         struct regcache *regcache,
  1143.                         int regnum, const void *buf, size_t size)
  1144. {
  1145.   regcache_transfer_regset (regset, regcache, regcache, regnum,
  1146.                             buf, NULL, size);
  1147. }

  1149. /* Collect register REGNUM from REGCACHE to BUF, using the register
  1150.    map in REGSET.  If REGNUM is -1, do this for all registers in
  1151.    REGSET.  */

  1153. void
  1154. ‌regcache_collect_regset (const struct regset *regset,
  1155.                          const struct regcache *regcache,
  1156.                          int regnum, void *buf, size_t size)
  1157. {
  1158.   regcache_transfer_regset (regset, regcache, NULL, regnum,
  1159.                             NULL, buf, size);
  1160. }


  1163. /* Special handling for register PC.  */

  1165. CORE_ADDR
  1166. ‌regcache_read_pc (struct regcache *regcache)
  1167. {
  1168.   struct gdbarch *gdbarch = get_regcache_arch (regcache);

  1170.   CORE_ADDR pc_val;

  1172.   if (gdbarch_read_pc_p (gdbarch))
  1173.     pc_val = gdbarch_read_pc (gdbarch, regcache);
  1174.   /* Else use per-frame method on get_current_frame.  */
  1175.   else if (gdbarch_pc_regnum (gdbarch) >= 0)
  1176.     {
  1177.       ULONGEST raw_val;

  1179.       if (regcache_cooked_read_unsigned (regcache,
  1180.                                          gdbarch_pc_regnum (gdbarch),
  1181.                                          &raw_val) == REG_UNAVAILABLE)
  1182.         throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));

  1184.       pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
  1185.     }
  1186.   else
  1187.     internal_error (__FILE__, __LINE__,
  1188.                     _("regcache_read_pc: Unable to find PC"));
  1189.   return pc_val;
  1190. }

  1192. void
  1193. ‌regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
  1194. {
  1195.   struct gdbarch *gdbarch = get_regcache_arch (regcache);

  1197.   if (gdbarch_write_pc_p (gdbarch))
  1198.     gdbarch_write_pc (gdbarch, regcache, pc);
  1199.   else if (gdbarch_pc_regnum (gdbarch) >= 0)
  1200.     regcache_cooked_write_unsigned (regcache,
  1201.                                     gdbarch_pc_regnum (gdbarch), pc);
  1202.   else
  1203.     internal_error (__FILE__, __LINE__,
  1204.                     _("regcache_write_pc: Unable to update PC"));

  1206.   /* Writing the PC (for instance, from "load") invalidates the
  1207.      current frame.  */
  1208.   reinit_frame_cache ();
  1209. }


  1212. static void
  1213. ‌reg_flush_command (char *command, int from_tty)
  1214. {
  1215.   /* Force-flush the register cache.  */
  1216.   registers_changed ();
  1217.   if (from_tty)
  1218.     printf_filtered (_("Register cache flushed.\n"));
  1219. }

  1221. ‌enum regcache_dump_what
  1222. {
  1223.   regcache_dump_none, regcache_dump_raw,
  1224.   regcache_dump_cooked, regcache_dump_groups,
  1225.   regcache_dump_remote
  1226. };

  1228. static void
  1229. ‌regcache_dump (struct regcache *regcache, struct ui_file *file,
  1230.                enum regcache_dump_what what_to_dump)
  1231. {
  1232.   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
  1233.   struct gdbarch *gdbarch = regcache->descr->gdbarch;
  1234.   int regnum;
  1235.   int footnote_nr = 0;
  1236.   int footnote_register_size = 0;
  1237.   int footnote_register_offset = 0;
  1238.   int footnote_register_type_name_null = 0;
  1239.   long register_offset = 0;
  1240.   gdb_byte buf[MAX_REGISTER_SIZE];

  1242. #if 0
  1243.   fprintf_unfiltered (file, "nr_raw_registers %d\n",
  1244.                       regcache->descr->nr_raw_registers);
  1245.   fprintf_unfiltered (file, "nr_cooked_registers %d\n",
  1246.                       regcache->descr->nr_cooked_registers);
  1247.   fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
  1248.                       regcache->descr->sizeof_raw_registers);
  1249.   fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
  1250.                       regcache->descr->sizeof_raw_register_status);
  1251.   fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
  1252.                       gdbarch_num_regs (gdbarch));
  1253.   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
  1254.                       gdbarch_num_pseudo_regs (gdbarch));
  1255. #endif

  1257.   gdb_assert (regcache->descr->nr_cooked_registers
  1258.               == (gdbarch_num_regs (gdbarch)
  1259.                   + gdbarch_num_pseudo_regs (gdbarch)));

  1261.   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
  1262.     {
  1263.       /* Name.  */
  1264.       if (regnum < 0)
  1265.         fprintf_unfiltered (file, " %-10s", "Name");
  1266.       else
  1267.         {
  1268.           const char *p = gdbarch_register_name (gdbarch, regnum);

  1270.           if (p == NULL)
  1271.             p = "";
  1272.           else if (p[0] == '\0')
  1273.             p = "''";
  1274.           fprintf_unfiltered (file, " %-10s", p);
  1275.         }

  1277.       /* Number.  */
  1278.       if (regnum < 0)
  1279.         fprintf_unfiltered (file, " %4s", "Nr");
  1280.       else
  1281.         fprintf_unfiltered (file, " %4d", regnum);

  1283.       /* Relative number.  */
  1284.       if (regnum < 0)
  1285.         fprintf_unfiltered (file, " %4s", "Rel");
  1286.       else if (regnum < gdbarch_num_regs (gdbarch))
  1287.         fprintf_unfiltered (file, " %4d", regnum);
  1288.       else
  1289.         fprintf_unfiltered (file, " %4d",
  1290.                             (regnum - gdbarch_num_regs (gdbarch)));

  1292.       /* Offset.  */
  1293.       if (regnum < 0)
  1294.         fprintf_unfiltered (file, " %6s  ", "Offset");
  1295.       else
  1296.         {
  1297.           fprintf_unfiltered (file, " %6ld",
  1298.                               regcache->descr->register_offset[regnum]);
  1299.           if (register_offset != regcache->descr->register_offset[regnum]
  1300.               || (regnum > 0
  1301.                   && (regcache->descr->register_offset[regnum]
  1302.                       != (regcache->descr->register_offset[regnum - 1]
  1303.                           + regcache->descr->sizeof_register[regnum - 1])))
  1304.               )
  1305.             {
  1306.               if (!footnote_register_offset)
  1307.                 footnote_register_offset = ++footnote_nr;
  1308.               fprintf_unfiltered (file, "*%d", footnote_register_offset);
  1309.             }
  1310.           else
  1311.             fprintf_unfiltered (file, "  ");
  1312.           register_offset = (regcache->descr->register_offset[regnum]
  1313.                              + regcache->descr->sizeof_register[regnum]);
  1314.         }

  1316.       /* Size.  */
  1317.       if (regnum < 0)
  1318.         fprintf_unfiltered (file, " %5s ", "Size");
  1319.       else
  1320.         fprintf_unfiltered (file, " %5ld",
  1321.                             regcache->descr->sizeof_register[regnum]);

  1323.       /* Type.  */
  1324.       {
  1325.         const char *t;

  1327.         if (regnum < 0)
  1328.           t = "Type";
  1329.         else
  1330.           {
  1331.             static const char blt[] = "builtin_type";

  1333.             t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
  1334.             if (t == NULL)
  1335.               {
  1336.                 char *n;

  1338.                 if (!footnote_register_type_name_null)
  1339.                   footnote_register_type_name_null = ++footnote_nr;
  1340.                 n = xstrprintf ("*%d", footnote_register_type_name_null);
  1341.                 make_cleanup (xfree, n);
  1342.                 t = n;
  1343.               }
  1344.             /* Chop a leading builtin_type.  */
  1345.             if (strncmp (t, blt, strlen (blt)) == 0)
  1346.               t += strlen (blt);
  1347.           }
  1348.         fprintf_unfiltered (file, " %-15s", t);
  1349.       }

  1351.       /* Leading space always present.  */
  1352.       fprintf_unfiltered (file, " ");

  1354.       /* Value, raw.  */
  1355.       if (what_to_dump == regcache_dump_raw)
  1356.         {
  1357.           if (regnum < 0)
  1358.             fprintf_unfiltered (file, "Raw value");
  1359.           else if (regnum >= regcache->descr->nr_raw_registers)
  1360.             fprintf_unfiltered (file, "<cooked>");
  1361.           else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
  1362.             fprintf_unfiltered (file, "<invalid>");
  1363.           else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
  1364.             fprintf_unfiltered (file, "<unavailable>");
  1365.           else
  1366.             {
  1367.               regcache_raw_read (regcache, regnum, buf);
  1368.               print_hex_chars (file, buf,
  1369.                                regcache->descr->sizeof_register[regnum],
  1370.                                gdbarch_byte_order (gdbarch));
  1371.             }
  1372.         }

  1374.       /* Value, cooked.  */
  1375.       if (what_to_dump == regcache_dump_cooked)
  1376.         {
  1377.           if (regnum < 0)
  1378.             fprintf_unfiltered (file, "Cooked value");
  1379.           else
  1380.             {
  1381.               enum register_status status;

  1383.               status = regcache_cooked_read (regcache, regnum, buf);
  1384.               if (status == REG_UNKNOWN)
  1385.                 fprintf_unfiltered (file, "<invalid>");
  1386.               else if (status == REG_UNAVAILABLE)
  1387.                 fprintf_unfiltered (file, "<unavailable>");
  1388.               else
  1389.                 print_hex_chars (file, buf,
  1390.                                  regcache->descr->sizeof_register[regnum],
  1391.                                  gdbarch_byte_order (gdbarch));
  1392.             }
  1393.         }

  1395.       /* Group members.  */
  1396.       if (what_to_dump == regcache_dump_groups)
  1397.         {
  1398.           if (regnum < 0)
  1399.             fprintf_unfiltered (file, "Groups");
  1400.           else
  1401.             {
  1402.               const char *sep = "";
  1403.               struct reggroup *group;

  1405.               for (group = reggroup_next (gdbarch, NULL);
  1406.                    group != NULL;
  1407.                    group = reggroup_next (gdbarch, group))
  1408.                 {
  1409.                   if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
  1410.                     {
  1411.                       fprintf_unfiltered (file,
  1412.                                           "%s%s", sep, reggroup_name (group));
  1413.                       sep = ",";
  1414.                     }
  1415.                 }
  1416.             }
  1417.         }

  1419.       /* Remote packet configuration.  */
  1420.       if (what_to_dump == regcache_dump_remote)
  1421.         {
  1422.           if (regnum < 0)
  1423.             {
  1424.               fprintf_unfiltered (file, "Rmt Nr  g/G Offset");
  1425.             }
  1426.           else if (regnum < regcache->descr->nr_raw_registers)
  1427.             {
  1428.               int pnum, poffset;

  1430.               if (remote_register_number_and_offset (get_regcache_arch (regcache), regnum,
  1431.                                                      &pnum, &poffset))
  1432.                 fprintf_unfiltered (file, "%7d %11d", pnum, poffset);
  1433.             }
  1434.         }

  1436.       fprintf_unfiltered (file, "\n");
  1437.     }

  1439.   if (footnote_register_size)
  1440.     fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
  1441.                         footnote_register_size);
  1442.   if (footnote_register_offset)
  1443.     fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
  1444.                         footnote_register_offset);
  1445.   if (footnote_register_type_name_null)
  1446.     fprintf_unfiltered (file,
  1447.                         "*%d: Register type's name NULL.\n",
  1448.                         footnote_register_type_name_null);
  1449.   do_cleanups (cleanups);
  1450. }

  1452. static void
  1453. ‌regcache_print (char *args, enum regcache_dump_what what_to_dump)
  1454. {
  1455.   if (args == NULL)
  1456.     regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
  1457.   else
  1458.     {
  1459.       struct cleanup *cleanups;
  1460.       struct ui_file *file = gdb_fopen (args, "w");

  1462.       if (file == NULL)
  1463.         perror_with_name (_("maintenance print architecture"));
  1464.       cleanups = make_cleanup_ui_file_delete (file);
  1465.       regcache_dump (get_current_regcache (), file, what_to_dump);
  1466.       do_cleanups (cleanups);
  1467.     }
  1468. }

  1470. static void
  1471. ‌maintenance_print_registers (char *args, int from_tty)
  1472. {
  1473.   regcache_print (args, regcache_dump_none);
  1474. }

  1476. static void
  1477. ‌maintenance_print_raw_registers (char *args, int from_tty)
  1478. {
  1479.   regcache_print (args, regcache_dump_raw);
  1480. }

  1482. static void
  1483. ‌maintenance_print_cooked_registers (char *args, int from_tty)
  1484. {
  1485.   regcache_print (args, regcache_dump_cooked);
  1486. }

  1488. static void
  1489. ‌maintenance_print_register_groups (char *args, int from_tty)
  1490. {
  1491.   regcache_print (args, regcache_dump_groups);
  1492. }

  1494. static void
  1495. ‌maintenance_print_remote_registers (char *args, int from_tty)
  1496. {
  1497.   regcache_print (args, regcache_dump_remote);
  1498. }

  1500. extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */

  1502. void
  1503. ‌_initialize_regcache (void)
  1504. {
  1505.   regcache_descr_handle
  1506.     = gdbarch_data_register_post_init (init_regcache_descr);

  1508.   observer_attach_target_changed (regcache_observer_target_changed);
  1509.   observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);

  1511.   add_com ("flushregs", class_maintenance, reg_flush_command,
  1512.            _("Force gdb to flush its register cache (maintainer command)"));

  1514.   add_cmd ("registers", class_maintenance, maintenance_print_registers,
  1515.            _("Print the internal register configuration.\n"
  1516.              "Takes an optional file parameter."), &maintenanceprintlist);
  1517.   add_cmd ("raw-registers", class_maintenance,
  1518.            maintenance_print_raw_registers,
  1519.            _("Print the internal register configuration "
  1520.              "including raw values.\n"
  1521.              "Takes an optional file parameter."), &maintenanceprintlist);
  1522.   add_cmd ("cooked-registers", class_maintenance,
  1523.            maintenance_print_cooked_registers,
  1524.            _("Print the internal register configuration "
  1525.              "including cooked values.\n"
  1526.              "Takes an optional file parameter."), &maintenanceprintlist);
  1527.   add_cmd ("register-groups", class_maintenance,
  1528.            maintenance_print_register_groups,
  1529.            _("Print the internal register configuration "
  1530.              "including each register's group.\n"
  1531.              "Takes an optional file parameter."),
  1532.            &maintenanceprintlist);
  1533.   add_cmd ("remote-registers", class_maintenance,
  1534.            maintenance_print_remote_registers, _("\
  1535. Print the internal register configuration including each register's\n\
  1536. remote register number and buffer offset in the g/G packets.\n\
  1537. Takes an optional file parameter."),
  1538.            &maintenanceprintlist);

  1540. }