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