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