GDB (xrefs)

/tmp/gdb-8.1/gdb/frame.c
Go to the documentation of this file.
1 /* Cache and manage frames for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 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 "frame.h"
22 #include "target.h"
23 #include "value.h"
24 #include "inferior.h" /* for inferior_ptid */
25 #include "regcache.h"
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
30 #include "gdbcore.h"
31 #include "annotate.h"
32 #include "language.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
35 #include "command.h"
36 #include "gdbcmd.h"
37 #include "observer.h"
38 #include "objfiles.h"
39 #include "gdbthread.h"
40 #include "block.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
43 #include "hashtab.h"
44 #include "valprint.h"
45
46 /* The sentinel frame terminates the innermost end of the frame chain.
47 If unwound, it returns the information needed to construct an
48 innermost frame.
49
50 The current frame, which is the innermost frame, can be found at
51 sentinel_frame->prev. */
52
53 static struct frame_info *sentinel_frame;
54
55 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
56 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
57
58 /* Status of some values cached in the frame_info object. */
59
60 enum cached_copy_status
61 {
62 /* Value is unknown. */
63 CC_UNKNOWN,
64
65 /* We have a value. */
66 CC_VALUE,
67
68 /* Value was not saved. */
69 CC_NOT_SAVED,
70
71 /* Value is unavailable. */
72 CC_UNAVAILABLE
73 };
74
75 /* We keep a cache of stack frames, each of which is a "struct
76 frame_info". The innermost one gets allocated (in
77 wait_for_inferior) each time the inferior stops; sentinel_frame
78 points to it. Additional frames get allocated (in get_prev_frame)
79 as needed, and are chained through the next and prev fields. Any
80 time that the frame cache becomes invalid (most notably when we
81 execute something, but also if we change how we interpret the
82 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
83 which reads new symbols)), we should call reinit_frame_cache. */
84
85 struct frame_info
86 {
87 /* Level of this frame. The inner-most (youngest) frame is at level
88 0. As you move towards the outer-most (oldest) frame, the level
89 increases. This is a cached value. It could just as easily be
90 computed by counting back from the selected frame to the inner
91 most frame. */
92 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
93 reserved to indicate a bogus frame - one that has been created
94 just to keep GDB happy (GDB always needs a frame). For the
95 moment leave this as speculation. */
96 int level;
97
98 /* The frame's program space. */
99 struct program_space *pspace;
100
101 /* The frame's address space. */
102 const address_space *aspace;
103
104 /* The frame's low-level unwinder and corresponding cache. The
105 low-level unwinder is responsible for unwinding register values
106 for the previous frame. The low-level unwind methods are
107 selected based on the presence, or otherwise, of register unwind
108 information such as CFI. */
109 void *prologue_cache;
110 const struct frame_unwind *unwind;
111
112 /* Cached copy of the previous frame's architecture. */
113 struct
114 {
115 int p;
116 struct gdbarch *arch;
117 } prev_arch;
118
119 /* Cached copy of the previous frame's resume address. */
120 struct {
121 enum cached_copy_status status;
122 CORE_ADDR value;
123 } prev_pc;
124
125 /* Cached copy of the previous frame's function address. */
126 struct
127 {
128 CORE_ADDR addr;
129 int p;
130 } prev_func;
131
132 /* This frame's ID. */
133 struct
134 {
135 int p;
136 struct frame_id value;
137 } this_id;
138
139 /* The frame's high-level base methods, and corresponding cache.
140 The high level base methods are selected based on the frame's
141 debug info. */
142 const struct frame_base *base;
143 void *base_cache;
144
145 /* Pointers to the next (down, inner, younger) and previous (up,
146 outer, older) frame_info's in the frame cache. */
147 struct frame_info *next; /* down, inner, younger */
148 int prev_p;
149 struct frame_info *prev; /* up, outer, older */
150
151 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
152 could. Only valid when PREV_P is set. */
153 enum unwind_stop_reason stop_reason;
154
155 /* A frame specific string describing the STOP_REASON in more detail.
156 Only valid when PREV_P is set, but even then may still be NULL. */
157 const char *stop_string;
158 };
159
160 /* A frame stash used to speed up frame lookups. Create a hash table
161 to stash frames previously accessed from the frame cache for
162 quicker subsequent retrieval. The hash table is emptied whenever
163 the frame cache is invalidated. */
164
165 static htab_t frame_stash;
166
167 /* Internal function to calculate a hash from the frame_id addresses,
168 using as many valid addresses as possible. Frames below level 0
169 are not stored in the hash table. */
170
171 static hashval_t
172 frame_addr_hash (const void *ap)
173 {
174 const struct frame_info *frame = (const struct frame_info *) ap;
175 const struct frame_id f_id = frame->this_id.value;
176 hashval_t hash = 0;
177
178 gdb_assert (f_id.stack_status != FID_STACK_INVALID
179 || f_id.code_addr_p
180 || f_id.special_addr_p);
181
182 if (f_id.stack_status == FID_STACK_VALID)
183 hash = iterative_hash (&f_id.stack_addr,
184 sizeof (f_id.stack_addr), hash);
185 if (f_id.code_addr_p)
186 hash = iterative_hash (&f_id.code_addr,
187 sizeof (f_id.code_addr), hash);
188 if (f_id.special_addr_p)
189 hash = iterative_hash (&f_id.special_addr,
190 sizeof (f_id.special_addr), hash);
191
192 return hash;
193 }
194
195 /* Internal equality function for the hash table. This function
196 defers equality operations to frame_id_eq. */
197
198 static int
199 frame_addr_hash_eq (const void *a, const void *b)
200 {
201 const struct frame_info *f_entry = (const struct frame_info *) a;
202 const struct frame_info *f_element = (const struct frame_info *) b;
203
204 return frame_id_eq (f_entry->this_id.value,
205 f_element->this_id.value);
206 }
207
208 /* Internal function to create the frame_stash hash table. 100 seems
209 to be a good compromise to start the hash table at. */
210
211 static void
212 frame_stash_create (void)
213 {
214 frame_stash = htab_create (100,
215 frame_addr_hash,
216 frame_addr_hash_eq,
217 NULL);
218 }
219
220 /* Internal function to add a frame to the frame_stash hash table.
221 Returns false if a frame with the same ID was already stashed, true
222 otherwise. */
223
224 static int
225 frame_stash_add (struct frame_info *frame)
226 {
227 struct frame_info **slot;
228
229 /* Do not try to stash the sentinel frame. */
230 gdb_assert (frame->level >= 0);
231
232 slot = (struct frame_info **) htab_find_slot (frame_stash,
233 frame,
234 INSERT);
235
236 /* If we already have a frame in the stack with the same id, we
237 either have a stack cycle (corrupted stack?), or some bug
238 elsewhere in GDB. In any case, ignore the duplicate and return
239 an indication to the caller. */
240 if (*slot != NULL)
241 return 0;
242
243 *slot = frame;
244 return 1;
245 }
246
247 /* Internal function to search the frame stash for an entry with the
248 given frame ID. If found, return that frame. Otherwise return
249 NULL. */
250
251 static struct frame_info *
252 frame_stash_find (struct frame_id id)
253 {
254 struct frame_info dummy;
255 struct frame_info *frame;
256
257 dummy.this_id.value = id;
258 frame = (struct frame_info *) htab_find (frame_stash, &dummy);
259 return frame;
260 }
261
262 /* Internal function to invalidate the frame stash by removing all
263 entries in it. This only occurs when the frame cache is
264 invalidated. */
265
266 static void
267 frame_stash_invalidate (void)
268 {
269 htab_empty (frame_stash);
270 }
271
272 /* Flag to control debugging. */
273
274 unsigned int frame_debug;
275 static void
276 show_frame_debug (struct ui_file *file, int from_tty,
277 struct cmd_list_element *c, const char *value)
278 {
279 fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
280 }
281
282 /* Flag to indicate whether backtraces should stop at main et.al. */
283
284 static int backtrace_past_main;
285 static void
286 show_backtrace_past_main (struct ui_file *file, int from_tty,
287 struct cmd_list_element *c, const char *value)
288 {
289 fprintf_filtered (file,
290 _("Whether backtraces should "
291 "continue past \"main\" is %s.\n"),
292 value);
293 }
294
295 static int backtrace_past_entry;
296 static void
297 show_backtrace_past_entry (struct ui_file *file, int from_tty,
298 struct cmd_list_element *c, const char *value)
299 {
300 fprintf_filtered (file, _("Whether backtraces should continue past the "
301 "entry point of a program is %s.\n"),
302 value);
303 }
304
305 static unsigned int backtrace_limit = UINT_MAX;
306 static void
307 show_backtrace_limit (struct ui_file *file, int from_tty,
308 struct cmd_list_element *c, const char *value)
309 {
310 fprintf_filtered (file,
311 _("An upper bound on the number "
312 "of backtrace levels is %s.\n"),
313 value);
314 }
315
316
317 static void
318 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
319 {
320 if (p)
321 fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
322 else
323 fprintf_unfiltered (file, "!%s", name);
324 }
325
326 void
327 fprint_frame_id (struct ui_file *file, struct frame_id id)
328 {
329 fprintf_unfiltered (file, "{");
330
331 if (id.stack_status == FID_STACK_INVALID)
332 fprintf_unfiltered (file, "!stack");
333 else if (id.stack_status == FID_STACK_UNAVAILABLE)
334 fprintf_unfiltered (file, "stack=<unavailable>");
335 else if (id.stack_status == FID_STACK_SENTINEL)
336 fprintf_unfiltered (file, "stack=<sentinel>");
337 else
338 fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr));
339 fprintf_unfiltered (file, ",");
340
341 fprint_field (file, "code", id.code_addr_p, id.code_addr);
342 fprintf_unfiltered (file, ",");
343
344 fprint_field (file, "special", id.special_addr_p, id.special_addr);
345
346 if (id.artificial_depth)
347 fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth);
348
349 fprintf_unfiltered (file, "}");
350 }
351
352 static void
353 fprint_frame_type (struct ui_file *file, enum frame_type type)
354 {
355 switch (type)
356 {
357 case NORMAL_FRAME:
358 fprintf_unfiltered (file, "NORMAL_FRAME");
359 return;
360 case DUMMY_FRAME:
361 fprintf_unfiltered (file, "DUMMY_FRAME");
362 return;
363 case INLINE_FRAME:
364 fprintf_unfiltered (file, "INLINE_FRAME");
365 return;
366 case TAILCALL_FRAME:
367 fprintf_unfiltered (file, "TAILCALL_FRAME");
368 return;
369 case SIGTRAMP_FRAME:
370 fprintf_unfiltered (file, "SIGTRAMP_FRAME");
371 return;
372 case ARCH_FRAME:
373 fprintf_unfiltered (file, "ARCH_FRAME");
374 return;
375 case SENTINEL_FRAME:
376 fprintf_unfiltered (file, "SENTINEL_FRAME");
377 return;
378 default:
379 fprintf_unfiltered (file, "<unknown type>");
380 return;
381 };
382 }
383
384 static void
385 fprint_frame (struct ui_file *file, struct frame_info *fi)
386 {
387 if (fi == NULL)
388 {
389 fprintf_unfiltered (file, "<NULL frame>");
390 return;
391 }
392 fprintf_unfiltered (file, "{");
393 fprintf_unfiltered (file, "level=%d", fi->level);
394 fprintf_unfiltered (file, ",");
395 fprintf_unfiltered (file, "type=");
396 if (fi->unwind != NULL)
397 fprint_frame_type (file, fi->unwind->type);
398 else
399 fprintf_unfiltered (file, "<unknown>");
400 fprintf_unfiltered (file, ",");
401 fprintf_unfiltered (file, "unwind=");
402 if (fi->unwind != NULL)
403 gdb_print_host_address (fi->unwind, file);
404 else
405 fprintf_unfiltered (file, "<unknown>");
406 fprintf_unfiltered (file, ",");
407 fprintf_unfiltered (file, "pc=");
408 if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN)
409 fprintf_unfiltered (file, "<unknown>");
410 else if (fi->next->prev_pc.status == CC_VALUE)
411 fprintf_unfiltered (file, "%s",
412 hex_string (fi->next->prev_pc.value));
413 else if (fi->next->prev_pc.status == CC_NOT_SAVED)
414 val_print_not_saved (file);
415 else if (fi->next->prev_pc.status == CC_UNAVAILABLE)
416 val_print_unavailable (file);
417 fprintf_unfiltered (file, ",");
418 fprintf_unfiltered (file, "id=");
419 if (fi->this_id.p)
420 fprint_frame_id (file, fi->this_id.value);
421 else
422 fprintf_unfiltered (file, "<unknown>");
423 fprintf_unfiltered (file, ",");
424 fprintf_unfiltered (file, "func=");
425 if (fi->next != NULL && fi->next->prev_func.p)
426 fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
427 else
428 fprintf_unfiltered (file, "<unknown>");
429 fprintf_unfiltered (file, "}");
430 }
431
432 /* Given FRAME, return the enclosing frame as found in real frames read-in from
433 inferior memory. Skip any previous frames which were made up by GDB.
434 Return FRAME if FRAME is a non-artificial frame.
435 Return NULL if FRAME is the start of an artificial-only chain. */
436
437 static struct frame_info *
438 skip_artificial_frames (struct frame_info *frame)
439 {
440 /* Note we use get_prev_frame_always, and not get_prev_frame. The
441 latter will truncate the frame chain, leading to this function
442 unintentionally returning a null_frame_id (e.g., when the user
443 sets a backtrace limit).
444
445 Note that for record targets we may get a frame chain that consists
446 of artificial frames only. */
447 while (get_frame_type (frame) == INLINE_FRAME
448 || get_frame_type (frame) == TAILCALL_FRAME)
449 {
450 frame = get_prev_frame_always (frame);
451 if (frame == NULL)
452 break;
453 }
454
455 return frame;
456 }
457
458 struct frame_info *
459 skip_unwritable_frames (struct frame_info *frame)
460 {
461 while (gdbarch_code_of_frame_writable (get_frame_arch (frame), frame) == 0)
462 {
463 frame = get_prev_frame (frame);
464 if (frame == NULL)
465 break;
466 }
467
468 return frame;
469 }
470
471 /* See frame.h. */
472
473 struct frame_info *
474 skip_tailcall_frames (struct frame_info *frame)
475 {
476 while (get_frame_type (frame) == TAILCALL_FRAME)
477 {
478 /* Note that for record targets we may get a frame chain that consists of
479 tailcall frames only. */
480 frame = get_prev_frame (frame);
481 if (frame == NULL)
482 break;
483 }
484
485 return frame;
486 }
487
488 /* Compute the frame's uniq ID that can be used to, later, re-find the
489 frame. */
490
491 static void
492 compute_frame_id (struct frame_info *fi)
493 {
494 gdb_assert (!fi->this_id.p);
495
496 if (frame_debug)
497 fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ",
498 fi->level);
499 /* Find the unwinder. */
500 if (fi->unwind == NULL)
501 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
502 /* Find THIS frame's ID. */
503 /* Default to outermost if no ID is found. */
504 fi->this_id.value = outer_frame_id;
505 fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
506 gdb_assert (frame_id_p (fi->this_id.value));
507 fi->this_id.p = 1;
508 if (frame_debug)
509 {
510 fprintf_unfiltered (gdb_stdlog, "-> ");
511 fprint_frame_id (gdb_stdlog, fi->this_id.value);
512 fprintf_unfiltered (gdb_stdlog, " }\n");
513 }
514 }
515
516 /* Return a frame uniq ID that can be used to, later, re-find the
517 frame. */
518
519 struct frame_id
520 get_frame_id (struct frame_info *fi)
521 {
522 if (fi == NULL)
523 return null_frame_id;
524
525 if (!fi->this_id.p)
526 {
527 int stashed;
528
529 /* If we haven't computed the frame id yet, then it must be that
530 this is the current frame. Compute it now, and stash the
531 result. The IDs of other frames are computed as soon as
532 they're created, in order to detect cycles. See
533 get_prev_frame_if_no_cycle. */
534 gdb_assert (fi->level == 0);
535
536 /* Compute. */
537 compute_frame_id (fi);
538
539 /* Since this is the first frame in the chain, this should
540 always succeed. */
541 stashed = frame_stash_add (fi);
542 gdb_assert (stashed);
543 }
544
545 return fi->this_id.value;
546 }
547
548 struct frame_id
549 get_stack_frame_id (struct frame_info *next_frame)
550 {
551 return get_frame_id (skip_artificial_frames (next_frame));
552 }
553
554 struct frame_id
555 frame_unwind_caller_id (struct frame_info *next_frame)
556 {
557 struct frame_info *this_frame;
558
559 /* Use get_prev_frame_always, and not get_prev_frame. The latter
560 will truncate the frame chain, leading to this function
561 unintentionally returning a null_frame_id (e.g., when a caller
562 requests the frame ID of "main()"s caller. */
563
564 next_frame = skip_artificial_frames (next_frame);
565 if (next_frame == NULL)
566 return null_frame_id;
567
568 this_frame = get_prev_frame_always (next_frame);
569 if (this_frame)
570 return get_frame_id (skip_artificial_frames (this_frame));
571 else
572 return null_frame_id;
573 }
574
575 const struct frame_id null_frame_id = { 0 }; /* All zeros. */
576 const struct frame_id sentinel_frame_id = { 0, 0, 0, FID_STACK_SENTINEL, 0, 1, 0 };
577 const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 };
578
579 struct frame_id
580 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
581 CORE_ADDR special_addr)
582 {
583 struct frame_id id = null_frame_id;
584
585 id.stack_addr = stack_addr;
586 id.stack_status = FID_STACK_VALID;
587 id.code_addr = code_addr;
588 id.code_addr_p = 1;
589 id.special_addr = special_addr;
590 id.special_addr_p = 1;
591 return id;
592 }
593
594 /* See frame.h. */
595
596 struct frame_id
597 frame_id_build_unavailable_stack (CORE_ADDR code_addr)
598 {
599 struct frame_id id = null_frame_id;
600
601 id.stack_status = FID_STACK_UNAVAILABLE;
602 id.code_addr = code_addr;
603 id.code_addr_p = 1;
604 return id;
605 }
606
607 /* See frame.h. */
608
609 struct frame_id
610 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
611 CORE_ADDR special_addr)
612 {
613 struct frame_id id = null_frame_id;
614
615 id.stack_status = FID_STACK_UNAVAILABLE;
616 id.code_addr = code_addr;
617 id.code_addr_p = 1;
618 id.special_addr = special_addr;
619 id.special_addr_p = 1;
620 return id;
621 }
622
623 struct frame_id
624 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
625 {
626 struct frame_id id = null_frame_id;
627
628 id.stack_addr = stack_addr;
629 id.stack_status = FID_STACK_VALID;
630 id.code_addr = code_addr;
631 id.code_addr_p = 1;
632 return id;
633 }
634
635 struct frame_id
636 frame_id_build_wild (CORE_ADDR stack_addr)
637 {
638 struct frame_id id = null_frame_id;
639
640 id.stack_addr = stack_addr;
641 id.stack_status = FID_STACK_VALID;
642 return id;
643 }
644
645 int
646 frame_id_p (struct frame_id l)
647 {
648 int p;
649
650 /* The frame is valid iff it has a valid stack address. */
651 p = l.stack_status != FID_STACK_INVALID;
652 /* outer_frame_id is also valid. */
653 if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
654 p = 1;
655 if (frame_debug)
656 {
657 fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
658 fprint_frame_id (gdb_stdlog, l);
659 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
660 }
661 return p;
662 }
663
664 int
665 frame_id_artificial_p (struct frame_id l)
666 {
667 if (!frame_id_p (l))
668 return 0;
669
670 return (l.artificial_depth != 0);
671 }
672
673 int
674 frame_id_eq (struct frame_id l, struct frame_id r)
675 {
676 int eq;
677
678 if (l.stack_status == FID_STACK_INVALID && l.special_addr_p
679 && r.stack_status == FID_STACK_INVALID && r.special_addr_p)
680 /* The outermost frame marker is equal to itself. This is the
681 dodgy thing about outer_frame_id, since between execution steps
682 we might step into another function - from which we can't
683 unwind either. More thought required to get rid of
684 outer_frame_id. */
685 eq = 1;
686 else if (l.stack_status == FID_STACK_INVALID
687 || r.stack_status == FID_STACK_INVALID)
688 /* Like a NaN, if either ID is invalid, the result is false.
689 Note that a frame ID is invalid iff it is the null frame ID. */
690 eq = 0;
691 else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
692 /* If .stack addresses are different, the frames are different. */
693 eq = 0;
694 else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
695 /* An invalid code addr is a wild card. If .code addresses are
696 different, the frames are different. */
697 eq = 0;
698 else if (l.special_addr_p && r.special_addr_p
699 && l.special_addr != r.special_addr)
700 /* An invalid special addr is a wild card (or unused). Otherwise
701 if special addresses are different, the frames are different. */
702 eq = 0;
703 else if (l.artificial_depth != r.artificial_depth)
704 /* If artifical depths are different, the frames must be different. */
705 eq = 0;
706 else
707 /* Frames are equal. */
708 eq = 1;
709
710 if (frame_debug)
711 {
712 fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
713 fprint_frame_id (gdb_stdlog, l);
714 fprintf_unfiltered (gdb_stdlog, ",r=");
715 fprint_frame_id (gdb_stdlog, r);
716 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
717 }
718 return eq;
719 }
720
721 /* Safety net to check whether frame ID L should be inner to
722 frame ID R, according to their stack addresses.
723
724 This method cannot be used to compare arbitrary frames, as the
725 ranges of valid stack addresses may be discontiguous (e.g. due
726 to sigaltstack).
727
728 However, it can be used as safety net to discover invalid frame
729 IDs in certain circumstances. Assuming that NEXT is the immediate
730 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
731
732 * The stack address of NEXT must be inner-than-or-equal to the stack
733 address of THIS.
734
735 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
736 error has occurred.
737
738 * If NEXT and THIS have different stack addresses, no other frame
739 in the frame chain may have a stack address in between.
740
741 Therefore, if frame_id_inner (TEST, THIS) holds, but
742 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
743 to a valid frame in the frame chain.
744
745 The sanity checks above cannot be performed when a SIGTRAMP frame
746 is involved, because signal handlers might be executed on a different
747 stack than the stack used by the routine that caused the signal
748 to be raised. This can happen for instance when a thread exceeds
749 its maximum stack size. In this case, certain compilers implement
750 a stack overflow strategy that cause the handler to be run on a
751 different stack. */
752
753 static int
754 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
755 {
756 int inner;
757
758 if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID)
759 /* Like NaN, any operation involving an invalid ID always fails.
760 Likewise if either ID has an unavailable stack address. */
761 inner = 0;
762 else if (l.artificial_depth > r.artificial_depth
763 && l.stack_addr == r.stack_addr
764 && l.code_addr_p == r.code_addr_p
765 && l.special_addr_p == r.special_addr_p
766 && l.special_addr == r.special_addr)
767 {
768 /* Same function, different inlined functions. */
769 const struct block *lb, *rb;
770
771 gdb_assert (l.code_addr_p && r.code_addr_p);
772
773 lb = block_for_pc (l.code_addr);
774 rb = block_for_pc (r.code_addr);
775
776 if (lb == NULL || rb == NULL)
777 /* Something's gone wrong. */
778 inner = 0;
779 else
780 /* This will return true if LB and RB are the same block, or
781 if the block with the smaller depth lexically encloses the
782 block with the greater depth. */
783 inner = contained_in (lb, rb);
784 }
785 else
786 /* Only return non-zero when strictly inner than. Note that, per
787 comment in "frame.h", there is some fuzz here. Frameless
788 functions are not strictly inner than (same .stack but
789 different .code and/or .special address). */
790 inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
791 if (frame_debug)
792 {
793 fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
794 fprint_frame_id (gdb_stdlog, l);
795 fprintf_unfiltered (gdb_stdlog, ",r=");
796 fprint_frame_id (gdb_stdlog, r);
797 fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
798 }
799 return inner;
800 }
801
802 struct frame_info *
803 frame_find_by_id (struct frame_id id)
804 {
805 struct frame_info *frame, *prev_frame;
806
807 /* ZERO denotes the null frame, let the caller decide what to do
808 about it. Should it instead return get_current_frame()? */
809 if (!frame_id_p (id))
810 return NULL;
811
812 /* Check for the sentinel frame. */
813 if (frame_id_eq (id, sentinel_frame_id))
814 return sentinel_frame;
815
816 /* Try using the frame stash first. Finding it there removes the need
817 to perform the search by looping over all frames, which can be very
818 CPU-intensive if the number of frames is very high (the loop is O(n)
819 and get_prev_frame performs a series of checks that are relatively
820 expensive). This optimization is particularly useful when this function
821 is called from another function (such as value_fetch_lazy, case
822 VALUE_LVAL (val) == lval_register) which already loops over all frames,
823 making the overall behavior O(n^2). */
824 frame = frame_stash_find (id);
825 if (frame)
826 return frame;
827
828 for (frame = get_current_frame (); ; frame = prev_frame)
829 {
830 struct frame_id self = get_frame_id (frame);
831
832 if (frame_id_eq (id, self))
833 /* An exact match. */
834 return frame;
835
836 prev_frame = get_prev_frame (frame);
837 if (!prev_frame)
838 return NULL;
839
840 /* As a safety net to avoid unnecessary backtracing while trying
841 to find an invalid ID, we check for a common situation where
842 we can detect from comparing stack addresses that no other
843 frame in the current frame chain can have this ID. See the
844 comment at frame_id_inner for details. */
845 if (get_frame_type (frame) == NORMAL_FRAME
846 && !frame_id_inner (get_frame_arch (frame), id, self)
847 && frame_id_inner (get_frame_arch (prev_frame), id,
848 get_frame_id (prev_frame)))
849 return NULL;
850 }
851 return NULL;
852 }
853
854 static CORE_ADDR
855 frame_unwind_pc (struct frame_info *this_frame)
856 {
857 if (this_frame->prev_pc.status == CC_UNKNOWN)
858 {
859 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
860 {
861 struct gdbarch *prev_gdbarch;
862 CORE_ADDR pc = 0;
863 int pc_p = 0;
864
865 /* The right way. The `pure' way. The one true way. This
866 method depends solely on the register-unwind code to
867 determine the value of registers in THIS frame, and hence
868 the value of this frame's PC (resume address). A typical
869 implementation is no more than:
870
871 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
872 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
873
874 Note: this method is very heavily dependent on a correct
875 register-unwind implementation, it pays to fix that
876 method first; this method is frame type agnostic, since
877 it only deals with register values, it works with any
878 frame. This is all in stark contrast to the old
879 FRAME_SAVED_PC which would try to directly handle all the
880 different ways that a PC could be unwound. */
881 prev_gdbarch = frame_unwind_arch (this_frame);
882
883 TRY
884 {
885 pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
886 pc_p = 1;
887 }
888 CATCH (ex, RETURN_MASK_ERROR)
889 {
890 if (ex.error == NOT_AVAILABLE_ERROR)
891 {
892 this_frame->prev_pc.status = CC_UNAVAILABLE;
893
894 if (frame_debug)
895 fprintf_unfiltered (gdb_stdlog,
896 "{ frame_unwind_pc (this_frame=%d)"
897 " -> <unavailable> }\n",
898 this_frame->level);
899 }
900 else if (ex.error == OPTIMIZED_OUT_ERROR)
901 {
902 this_frame->prev_pc.status = CC_NOT_SAVED;
903
904 if (frame_debug)
905 fprintf_unfiltered (gdb_stdlog,
906 "{ frame_unwind_pc (this_frame=%d)"
907 " -> <not saved> }\n",
908 this_frame->level);
909 }
910 else
911 throw_exception (ex);
912 }
913 END_CATCH
914
915 if (pc_p)
916 {
917 this_frame->prev_pc.value = pc;
918 this_frame->prev_pc.status = CC_VALUE;
919 if (frame_debug)
920 fprintf_unfiltered (gdb_stdlog,
921 "{ frame_unwind_pc (this_frame=%d) "
922 "-> %s }\n",
923 this_frame->level,
924 hex_string (this_frame->prev_pc.value));
925 }
926 }
927 else
928 internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
929 }
930
931 if (this_frame->prev_pc.status == CC_VALUE)
932 return this_frame->prev_pc.value;
933 else if (this_frame->prev_pc.status == CC_UNAVAILABLE)
934 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
935 else if (this_frame->prev_pc.status == CC_NOT_SAVED)
936 throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved"));
937 else
938 internal_error (__FILE__, __LINE__,
939 "unexpected prev_pc status: %d",
940 (int) this_frame->prev_pc.status);
941 }
942
943 CORE_ADDR
944 frame_unwind_caller_pc (struct frame_info *this_frame)
945 {
946 this_frame = skip_artificial_frames (this_frame);
947
948 /* We must have a non-artificial frame. The caller is supposed to check
949 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
950 in this case. */
951 gdb_assert (this_frame != NULL);
952
953 return frame_unwind_pc (this_frame);
954 }
955
956 int
957 get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
958 {
959 struct frame_info *next_frame = this_frame->next;
960
961 if (!next_frame->prev_func.p)
962 {
963 CORE_ADDR addr_in_block;
964
965 /* Make certain that this, and not the adjacent, function is
966 found. */
967 if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
968 {
969 next_frame->prev_func.p = -1;
970 if (frame_debug)
971 fprintf_unfiltered (gdb_stdlog,
972 "{ get_frame_func (this_frame=%d)"
973 " -> unavailable }\n",
974 this_frame->level);
975 }
976 else
977 {
978 next_frame->prev_func.p = 1;
979 next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
980 if (frame_debug)
981 fprintf_unfiltered (gdb_stdlog,
982 "{ get_frame_func (this_frame=%d) -> %s }\n",
983 this_frame->level,
984 hex_string (next_frame->prev_func.addr));
985 }
986 }
987
988 if (next_frame->prev_func.p < 0)
989 {
990 *pc = -1;
991 return 0;
992 }
993 else
994 {
995 *pc = next_frame->prev_func.addr;
996 return 1;
997 }
998 }
999
1000 CORE_ADDR
1001 get_frame_func (struct frame_info *this_frame)
1002 {
1003 CORE_ADDR pc;
1004
1005 if (!get_frame_func_if_available (this_frame, &pc))
1006 throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
1007
1008 return pc;
1009 }
1010
1011 static enum register_status
1012 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
1013 {
1014 if (!deprecated_frame_register_read ((struct frame_info *) src, regnum, buf))
1015 return REG_UNAVAILABLE;
1016 else
1017 return REG_VALID;
1018 }
1019
1020 std::unique_ptr<struct regcache>
1021 frame_save_as_regcache (struct frame_info *this_frame)
1022 {
1023 std::unique_ptr<struct regcache> regcache
1024 (new struct regcache (get_frame_arch (this_frame)));
1025
1026 regcache_save (regcache.get (), do_frame_register_read, this_frame);
1027 return regcache;
1028 }
1029
1030 void
1031 frame_pop (struct frame_info *this_frame)
1032 {
1033 struct frame_info *prev_frame;
1034
1035 if (get_frame_type (this_frame) == DUMMY_FRAME)
1036 {
1037 /* Popping a dummy frame involves restoring more than just registers.
1038 dummy_frame_pop does all the work. */
1039 dummy_frame_pop (get_frame_id (this_frame), inferior_ptid);
1040 return;
1041 }
1042
1043 /* Ensure that we have a frame to pop to. */
1044 prev_frame = get_prev_frame_always (this_frame);
1045
1046 if (!prev_frame)
1047 error (_("Cannot pop the initial frame."));
1048
1049 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1050 entering THISFRAME. */
1051 prev_frame = skip_tailcall_frames (prev_frame);
1052
1053 if (prev_frame == NULL)
1054 error (_("Cannot find the caller frame."));
1055
1056 /* Make a copy of all the register values unwound from this frame.
1057 Save them in a scratch buffer so that there isn't a race between
1058 trying to extract the old values from the current regcache while
1059 at the same time writing new values into that same cache. */
1060 std::unique_ptr<struct regcache> scratch
1061 = frame_save_as_regcache (prev_frame);
1062
1063 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1064 target's register cache that it is about to be hit with a burst
1065 register transfer and that the sequence of register writes should
1066 be batched. The pair target_prepare_to_store() and
1067 target_store_registers() kind of suggest this functionality.
1068 Unfortunately, they don't implement it. Their lack of a formal
1069 definition can lead to targets writing back bogus values
1070 (arguably a bug in the target code mind). */
1071 /* Now copy those saved registers into the current regcache.
1072 Here, regcache_cpy() calls regcache_restore(). */
1073 regcache_cpy (get_current_regcache (), scratch.get ());
1074
1075 /* We've made right mess of GDB's local state, just discard
1076 everything. */
1077 reinit_frame_cache ();
1078 }
1079
1080 void
1081 frame_register_unwind (struct frame_info *frame, int regnum,
1082 int *optimizedp, int *unavailablep,
1083 enum lval_type *lvalp, CORE_ADDR *addrp,
1084 int *realnump, gdb_byte *bufferp)
1085 {
1086 struct value *value;
1087
1088 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1089 that the value proper does not need to be fetched. */
1090 gdb_assert (optimizedp != NULL);
1091 gdb_assert (lvalp != NULL);
1092 gdb_assert (addrp != NULL);
1093 gdb_assert (realnump != NULL);
1094 /* gdb_assert (bufferp != NULL); */
1095
1096 value = frame_unwind_register_value (frame, regnum);
1097
1098 gdb_assert (value != NULL);
1099
1100 *optimizedp = value_optimized_out (value);
1101 *unavailablep = !value_entirely_available (value);
1102 *lvalp = VALUE_LVAL (value);
1103 *addrp = value_address (value);
1104 if (*lvalp == lval_register)
1105 *realnump = VALUE_REGNUM (value);
1106 else
1107 *realnump = -1;
1108
1109 if (bufferp)
1110 {
1111 if (!*optimizedp && !*unavailablep)
1112 memcpy (bufferp, value_contents_all (value),
1113 TYPE_LENGTH (value_type (value)));
1114 else
1115 memset (bufferp, 0, TYPE_LENGTH (value_type (value)));
1116 }
1117
1118 /* Dispose of the new value. This prevents watchpoints from
1119 trying to watch the saved frame pointer. */
1120 release_value (value);
1121 value_free (value);
1122 }
1123
1124 void
1125 frame_register (struct frame_info *frame, int regnum,
1126 int *optimizedp, int *unavailablep, enum lval_type *lvalp,
1127 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
1128 {
1129 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1130 that the value proper does not need to be fetched. */
1131 gdb_assert (optimizedp != NULL);
1132 gdb_assert (lvalp != NULL);
1133 gdb_assert (addrp != NULL);
1134 gdb_assert (realnump != NULL);
1135 /* gdb_assert (bufferp != NULL); */
1136
1137 /* Obtain the register value by unwinding the register from the next
1138 (more inner frame). */
1139 gdb_assert (frame != NULL && frame->next != NULL);
1140 frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
1141 lvalp, addrp, realnump, bufferp);
1142 }
1143
1144 void
1145 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
1146 {
1147 int optimized;
1148 int unavailable;
1149 CORE_ADDR addr;
1150 int realnum;
1151 enum lval_type lval;
1152
1153 frame_register_unwind (frame, regnum, &optimized, &unavailable,
1154 &lval, &addr, &realnum, buf);
1155
1156 if (optimized)
1157 throw_error (OPTIMIZED_OUT_ERROR,
1158 _("Register %d was not saved"), regnum);
1159 if (unavailable)
1160 throw_error (NOT_AVAILABLE_ERROR,
1161 _("Register %d is not available"), regnum);
1162 }
1163
1164 void
1165 get_frame_register (struct frame_info *frame,
1166 int regnum, gdb_byte *buf)
1167 {
1168 frame_unwind_register (frame->next, regnum, buf);
1169 }
1170
1171 struct value *
1172 frame_unwind_register_value (struct frame_info *frame, int regnum)
1173 {
1174 struct gdbarch *gdbarch;
1175 struct value *value;
1176
1177 gdb_assert (frame != NULL);
1178 gdbarch = frame_unwind_arch (frame);
1179
1180 if (frame_debug)
1181 {
1182 fprintf_unfiltered (gdb_stdlog,
1183 "{ frame_unwind_register_value "
1184 "(frame=%d,regnum=%d(%s),...) ",
1185 frame->level, regnum,
1186 user_reg_map_regnum_to_name (gdbarch, regnum));
1187 }
1188
1189 /* Find the unwinder. */
1190 if (frame->unwind == NULL)
1191 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1192
1193 /* Ask this frame to unwind its register. */
1194 value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
1195
1196 if (frame_debug)
1197 {
1198 fprintf_unfiltered (gdb_stdlog, "->");
1199 if (value_optimized_out (value))
1200 {
1201 fprintf_unfiltered (gdb_stdlog, " ");
1202 val_print_optimized_out (value, gdb_stdlog);
1203 }
1204 else
1205 {
1206 if (VALUE_LVAL (value) == lval_register)
1207 fprintf_unfiltered (gdb_stdlog, " register=%d",
1208 VALUE_REGNUM (value));
1209 else if (VALUE_LVAL (value) == lval_memory)
1210 fprintf_unfiltered (gdb_stdlog, " address=%s",
1211 paddress (gdbarch,
1212 value_address (value)));
1213 else
1214 fprintf_unfiltered (gdb_stdlog, " computed");
1215
1216 if (value_lazy (value))
1217 fprintf_unfiltered (gdb_stdlog, " lazy");
1218 else
1219 {
1220 int i;
1221 const gdb_byte *buf = value_contents (value);
1222
1223 fprintf_unfiltered (gdb_stdlog, " bytes=");
1224 fprintf_unfiltered (gdb_stdlog, "[");
1225 for (i = 0; i < register_size (gdbarch, regnum); i++)
1226 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1227 fprintf_unfiltered (gdb_stdlog, "]");
1228 }
1229 }
1230
1231 fprintf_unfiltered (gdb_stdlog, " }\n");
1232 }
1233
1234 return value;
1235 }
1236
1237 struct value *
1238 get_frame_register_value (struct frame_info *frame, int regnum)
1239 {
1240 return frame_unwind_register_value (frame->next, regnum);
1241 }
1242
1243 LONGEST
1244 frame_unwind_register_signed (struct frame_info *frame, int regnum)
1245 {
1246 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1247 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1248 int size = register_size (gdbarch, regnum);
1249 struct value *value = frame_unwind_register_value (frame, regnum);
1250
1251 gdb_assert (value != NULL);
1252
1253 if (value_optimized_out (value))
1254 {
1255 throw_error (OPTIMIZED_OUT_ERROR,
1256 _("Register %d was not saved"), regnum);
1257 }
1258 if (!value_entirely_available (value))
1259 {
1260 throw_error (NOT_AVAILABLE_ERROR,
1261 _("Register %d is not available"), regnum);
1262 }
1263
1264 LONGEST r = extract_signed_integer (value_contents_all (value), size,
1265 byte_order);
1266
1267 release_value (value);
1268 value_free (value);
1269 return r;
1270 }
1271
1272 LONGEST
1273 get_frame_register_signed (struct frame_info *frame, int regnum)
1274 {
1275 return frame_unwind_register_signed (frame->next, regnum);
1276 }
1277
1278 ULONGEST
1279 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
1280 {
1281 struct gdbarch *gdbarch = frame_unwind_arch (frame);
1282 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1283 int size = register_size (gdbarch, regnum);
1284 struct value *value = frame_unwind_register_value (frame, regnum);
1285
1286 gdb_assert (value != NULL);
1287
1288 if (value_optimized_out (value))
1289 {
1290 throw_error (OPTIMIZED_OUT_ERROR,
1291 _("Register %d was not saved"), regnum);
1292 }
1293 if (!value_entirely_available (value))
1294 {
1295 throw_error (NOT_AVAILABLE_ERROR,
1296 _("Register %d is not available"), regnum);
1297 }
1298
1299 ULONGEST r = extract_unsigned_integer (value_contents_all (value), size,
1300 byte_order);
1301
1302 release_value (value);
1303 value_free (value);
1304 return r;
1305 }
1306
1307 ULONGEST
1308 get_frame_register_unsigned (struct frame_info *frame, int regnum)
1309 {
1310 return frame_unwind_register_unsigned (frame->next, regnum);
1311 }
1312
1313 int
1314 read_frame_register_unsigned (struct frame_info *frame, int regnum,
1315 ULONGEST *val)
1316 {
1317 struct value *regval = get_frame_register_value (frame, regnum);
1318
1319 if (!value_optimized_out (regval)
1320 && value_entirely_available (regval))
1321 {
1322 struct gdbarch *gdbarch = get_frame_arch (frame);
1323 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1324 int size = register_size (gdbarch, VALUE_REGNUM (regval));
1325
1326 *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
1327 return 1;
1328 }
1329
1330 return 0;
1331 }
1332
1333 void
1334 put_frame_register (struct frame_info *frame, int regnum,
1335 const gdb_byte *buf)
1336 {
1337 struct gdbarch *gdbarch = get_frame_arch (frame);
1338 int realnum;
1339 int optim;
1340 int unavail;
1341 enum lval_type lval;
1342 CORE_ADDR addr;
1343
1344 frame_register (frame, regnum, &optim, &unavail,
1345 &lval, &addr, &realnum, NULL);
1346 if (optim)
1347 error (_("Attempt to assign to a register that was not saved."));
1348 switch (lval)
1349 {
1350 case lval_memory:
1351 {
1352 write_memory (addr, buf, register_size (gdbarch, regnum));
1353 break;
1354 }
1355 case lval_register:
1356 regcache_cooked_write (get_current_regcache (), realnum, buf);
1357 break;
1358 default:
1359 error (_("Attempt to assign to an unmodifiable value."));
1360 }
1361 }
1362
1363 /* This function is deprecated. Use get_frame_register_value instead,
1364 which provides more accurate information.
1365
1366 Find and return the value of REGNUM for the specified stack frame.
1367 The number of bytes copied is REGISTER_SIZE (REGNUM).
1368
1369 Returns 0 if the register value could not be found. */
1370
1371 int
1372 deprecated_frame_register_read (struct frame_info *frame, int regnum,
1373 gdb_byte *myaddr)
1374 {
1375 int optimized;
1376 int unavailable;
1377 enum lval_type lval;
1378 CORE_ADDR addr;
1379 int realnum;
1380
1381 frame_register (frame, regnum, &optimized, &unavailable,
1382 &lval, &addr, &realnum, myaddr);
1383
1384 return !optimized && !unavailable;
1385 }
1386
1387 int
1388 get_frame_register_bytes (struct frame_info *frame, int regnum,
1389 CORE_ADDR offset, int len, gdb_byte *myaddr,
1390 int *optimizedp, int *unavailablep)
1391 {
1392 struct gdbarch *gdbarch = get_frame_arch (frame);
1393 int i;
1394 int maxsize;
1395 int numregs;
1396
1397 /* Skip registers wholly inside of OFFSET. */
1398 while (offset >= register_size (gdbarch, regnum))
1399 {
1400 offset -= register_size (gdbarch, regnum);
1401 regnum++;
1402 }
1403
1404 /* Ensure that we will not read beyond the end of the register file.
1405 This can only ever happen if the debug information is bad. */
1406 maxsize = -offset;
1407 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1408 for (i = regnum; i < numregs; i++)
1409 {
1410 int thissize = register_size (gdbarch, i);
1411
1412 if (thissize == 0)
1413 break; /* This register is not available on this architecture. */
1414 maxsize += thissize;
1415 }
1416 if (len > maxsize)
1417 error (_("Bad debug information detected: "
1418 "Attempt to read %d bytes from registers."), len);
1419
1420 /* Copy the data. */
1421 while (len > 0)
1422 {
1423 int curr_len = register_size (gdbarch, regnum) - offset;
1424
1425 if (curr_len > len)
1426 curr_len = len;
1427
1428 if (curr_len == register_size (gdbarch, regnum))
1429 {
1430 enum lval_type lval;
1431 CORE_ADDR addr;
1432 int realnum;
1433
1434 frame_register (frame, regnum, optimizedp, unavailablep,
1435 &lval, &addr, &realnum, myaddr);
1436 if (*optimizedp || *unavailablep)
1437 return 0;
1438 }
1439 else
1440 {
1441 struct value *value = frame_unwind_register_value (frame->next,
1442 regnum);
1443 gdb_assert (value != NULL);
1444 *optimizedp = value_optimized_out (value);
1445 *unavailablep = !value_entirely_available (value);
1446
1447 if (*optimizedp || *unavailablep)
1448 {
1449 release_value (value);
1450 value_free (value);
1451 return 0;
1452 }
1453 memcpy (myaddr, value_contents_all (value) + offset, curr_len);
1454 release_value (value);
1455 value_free (value);
1456 }
1457
1458 myaddr += curr_len;
1459 len -= curr_len;
1460 offset = 0;
1461 regnum++;
1462 }
1463
1464 *optimizedp = 0;
1465 *unavailablep = 0;
1466 return 1;
1467 }
1468
1469 void
1470 put_frame_register_bytes (struct frame_info *frame, int regnum,
1471 CORE_ADDR offset, int len, const gdb_byte *myaddr)
1472 {
1473 struct gdbarch *gdbarch = get_frame_arch (frame);
1474
1475 /* Skip registers wholly inside of OFFSET. */
1476 while (offset >= register_size (gdbarch, regnum))
1477 {
1478 offset -= register_size (gdbarch, regnum);
1479 regnum++;
1480 }
1481
1482 /* Copy the data. */
1483 while (len > 0)
1484 {
1485 int curr_len = register_size (gdbarch, regnum) - offset;
1486
1487 if (curr_len > len)
1488 curr_len = len;
1489
1490 if (curr_len == register_size (gdbarch, regnum))
1491 {
1492 put_frame_register (frame, regnum, myaddr);
1493 }
1494 else
1495 {
1496 struct value *value = frame_unwind_register_value (frame->next,
1497 regnum);
1498 gdb_assert (value != NULL);
1499
1500 memcpy ((char *) value_contents_writeable (value) + offset, myaddr,
1501 curr_len);
1502 put_frame_register (frame, regnum, value_contents_raw (value));
1503 release_value (value);
1504 value_free (value);
1505 }
1506
1507 myaddr += curr_len;
1508 len -= curr_len;
1509 offset = 0;
1510 regnum++;
1511 }
1512 }
1513
1514 /* Create a sentinel frame. */
1515
1516 static struct frame_info *
1517 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1518 {
1519 struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1520
1521 frame->level = -1;
1522 frame->pspace = pspace;
1523 frame->aspace = regcache->aspace ();
1524 /* Explicitly initialize the sentinel frame's cache. Provide it
1525 with the underlying regcache. In the future additional
1526 information, such as the frame's thread will be added. */
1527 frame->prologue_cache = sentinel_frame_cache (regcache);
1528 /* For the moment there is only one sentinel frame implementation. */
1529 frame->unwind = &sentinel_frame_unwind;
1530 /* Link this frame back to itself. The frame is self referential
1531 (the unwound PC is the same as the pc), so make it so. */
1532 frame->next = frame;
1533 /* The sentinel frame has a special ID. */
1534 frame->this_id.p = 1;
1535 frame->this_id.value = sentinel_frame_id;
1536 if (frame_debug)
1537 {
1538 fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1539 fprint_frame (gdb_stdlog, frame);
1540 fprintf_unfiltered (gdb_stdlog, " }\n");
1541 }
1542 return frame;
1543 }
1544
1545 /* Cache for frame addresses already read by gdb. Valid only while
1546 inferior is stopped. Control variables for the frame cache should
1547 be local to this module. */
1548
1549 static struct obstack frame_cache_obstack;
1550
1551 void *
1552 frame_obstack_zalloc (unsigned long size)
1553 {
1554 void *data = obstack_alloc (&frame_cache_obstack, size);
1555
1556 memset (data, 0, size);
1557 return data;
1558 }
1559
1560 static struct frame_info *get_prev_frame_always_1 (struct frame_info *this_frame);
1561
1562 struct frame_info *
1563 get_current_frame (void)
1564 {
1565 struct frame_info *current_frame;
1566
1567 /* First check, and report, the lack of registers. Having GDB
1568 report "No stack!" or "No memory" when the target doesn't even
1569 have registers is very confusing. Besides, "printcmd.exp"
1570 explicitly checks that ``print $pc'' with no registers prints "No
1571 registers". */
1572 if (!target_has_registers)
1573 error (_("No registers."));
1574 if (!target_has_stack)
1575 error (_("No stack."));
1576 if (!target_has_memory)
1577 error (_("No memory."));
1578 /* Traceframes are effectively a substitute for the live inferior. */
1579 if (get_traceframe_number () < 0)
1580 validate_registers_access ();
1581
1582 if (sentinel_frame == NULL)
1583 sentinel_frame =
1584 create_sentinel_frame (current_program_space, get_current_regcache ());
1585
1586 /* Set the current frame before computing the frame id, to avoid
1587 recursion inside compute_frame_id, in case the frame's
1588 unwinder decides to do a symbol lookup (which depends on the
1589 selected frame's block).
1590
1591 This call must always succeed. In particular, nothing inside
1592 get_prev_frame_always_1 should try to unwind from the
1593 sentinel frame, because that could fail/throw, and we always
1594 want to leave with the current frame created and linked in --
1595 we should never end up with the sentinel frame as outermost
1596 frame. */
1597 current_frame = get_prev_frame_always_1 (sentinel_frame);
1598 gdb_assert (current_frame != NULL);
1599
1600 return current_frame;
1601 }
1602
1603 /* The "selected" stack frame is used by default for local and arg
1604 access. May be zero, for no selected frame. */
1605
1606 static struct frame_info *selected_frame;
1607
1608 int
1609 has_stack_frames (void)
1610 {
1611 if (!target_has_registers || !target_has_stack || !target_has_memory)
1612 return 0;
1613
1614 /* Traceframes are effectively a substitute for the live inferior. */
1615 if (get_traceframe_number () < 0)
1616 {
1617 /* No current inferior, no frame. */
1618 if (ptid_equal (inferior_ptid, null_ptid))
1619 return 0;
1620
1621 /* Don't try to read from a dead thread. */
1622 if (is_exited (inferior_ptid))
1623 return 0;
1624
1625 /* ... or from a spinning thread. */
1626 if (is_executing (inferior_ptid))
1627 return 0;
1628 }
1629
1630 return 1;
1631 }
1632
1633 /* Return the selected frame. Always non-NULL (unless there isn't an
1634 inferior sufficient for creating a frame) in which case an error is
1635 thrown. */
1636
1637 struct frame_info *
1638 get_selected_frame (const char *message)
1639 {
1640 if (selected_frame == NULL)
1641 {
1642 if (message != NULL && !has_stack_frames ())
1643 error (("%s"), message);
1644 /* Hey! Don't trust this. It should really be re-finding the
1645 last selected frame of the currently selected thread. This,
1646 though, is better than nothing. */
1647 select_frame (get_current_frame ());
1648 }
1649 /* There is always a frame. */
1650 gdb_assert (selected_frame != NULL);
1651 return selected_frame;
1652 }
1653
1654 /* If there is a selected frame, return it. Otherwise, return NULL. */
1655
1656 struct frame_info *
1657 get_selected_frame_if_set (void)
1658 {
1659 return selected_frame;
1660 }
1661
1662 /* This is a variant of get_selected_frame() which can be called when
1663 the inferior does not have a frame; in that case it will return
1664 NULL instead of calling error(). */
1665
1666 struct frame_info *
1667 deprecated_safe_get_selected_frame (void)
1668 {
1669 if (!has_stack_frames ())
1670 return NULL;
1671 return get_selected_frame (NULL);
1672 }
1673
1674 /* Select frame FI (or NULL - to invalidate the current frame). */
1675
1676 void
1677 select_frame (struct frame_info *fi)
1678 {
1679 selected_frame = fi;
1680 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1681 frame is being invalidated. */
1682
1683 /* FIXME: kseitz/2002-08-28: It would be nice to call
1684 selected_frame_level_changed_event() right here, but due to limitations
1685 in the current interfaces, we would end up flooding UIs with events
1686 because select_frame() is used extensively internally.
1687
1688 Once we have frame-parameterized frame (and frame-related) commands,
1689 the event notification can be moved here, since this function will only
1690 be called when the user's selected frame is being changed. */
1691
1692 /* Ensure that symbols for this frame are read in. Also, determine the
1693 source language of this frame, and switch to it if desired. */
1694 if (fi)
1695 {
1696 CORE_ADDR pc;
1697
1698 /* We retrieve the frame's symtab by using the frame PC.
1699 However we cannot use the frame PC as-is, because it usually
1700 points to the instruction following the "call", which is
1701 sometimes the first instruction of another function. So we
1702 rely on get_frame_address_in_block() which provides us with a
1703 PC which is guaranteed to be inside the frame's code
1704 block. */
1705 if (get_frame_address_in_block_if_available (fi, &pc))
1706 {
1707 struct compunit_symtab *cust = find_pc_compunit_symtab (pc);
1708
1709 if (cust != NULL
1710 && compunit_language (cust) != current_language->la_language
1711 && compunit_language (cust) != language_unknown
1712 && language_mode == language_mode_auto)
1713 set_language (compunit_language (cust));
1714 }
1715 }
1716 }
1717
1718 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1719 Always returns a non-NULL value. */
1720
1721 struct frame_info *
1722 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1723 {
1724 struct frame_info *fi;
1725
1726 if (frame_debug)
1727 {
1728 fprintf_unfiltered (gdb_stdlog,
1729 "{ create_new_frame (addr=%s, pc=%s) ",
1730 hex_string (addr), hex_string (pc));
1731 }
1732
1733 fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1734
1735 fi->next = create_sentinel_frame (current_program_space,
1736 get_current_regcache ());
1737
1738 /* Set/update this frame's cached PC value, found in the next frame.
1739 Do this before looking for this frame's unwinder. A sniffer is
1740 very likely to read this, and the corresponding unwinder is
1741 entitled to rely that the PC doesn't magically change. */
1742 fi->next->prev_pc.value = pc;
1743 fi->next->prev_pc.status = CC_VALUE;
1744
1745 /* We currently assume that frame chain's can't cross spaces. */
1746 fi->pspace = fi->next->pspace;
1747 fi->aspace = fi->next->aspace;
1748
1749 /* Select/initialize both the unwind function and the frame's type
1750 based on the PC. */
1751 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1752
1753 fi->this_id.p = 1;
1754 fi->this_id.value = frame_id_build (addr, pc);
1755
1756 if (frame_debug)
1757 {
1758 fprintf_unfiltered (gdb_stdlog, "-> ");
1759 fprint_frame (gdb_stdlog, fi);
1760 fprintf_unfiltered (gdb_stdlog, " }\n");
1761 }
1762
1763 return fi;
1764 }
1765
1766 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1767 innermost frame). Be careful to not fall off the bottom of the
1768 frame chain and onto the sentinel frame. */
1769
1770 struct frame_info *
1771 get_next_frame (struct frame_info *this_frame)
1772 {
1773 if (this_frame->level > 0)
1774 return this_frame->next;
1775 else
1776 return NULL;
1777 }
1778
1779 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
1780 innermost (i.e. current) frame, return the sentinel frame. Thus,
1781 unlike get_next_frame(), NULL will never be returned. */
1782
1783 struct frame_info *
1784 get_next_frame_sentinel_okay (struct frame_info *this_frame)
1785 {
1786 gdb_assert (this_frame != NULL);
1787
1788 /* Note that, due to the manner in which the sentinel frame is
1789 constructed, this_frame->next still works even when this_frame
1790 is the sentinel frame. But we disallow it here anyway because
1791 calling get_next_frame_sentinel_okay() on the sentinel frame
1792 is likely a coding error. */
1793 gdb_assert (this_frame != sentinel_frame);
1794
1795 return this_frame->next;
1796 }
1797
1798 /* Observer for the target_changed event. */
1799
1800 static void
1801 frame_observer_target_changed (struct target_ops *target)
1802 {
1803 reinit_frame_cache ();
1804 }
1805
1806 /* Flush the entire frame cache. */
1807
1808 void
1809 reinit_frame_cache (void)
1810 {
1811 struct frame_info *fi;
1812
1813 /* Tear down all frame caches. */
1814 for (fi = sentinel_frame; fi != NULL; fi = fi->prev)
1815 {
1816 if (fi->prologue_cache && fi->unwind->dealloc_cache)
1817 fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1818 if (fi->base_cache && fi->base->unwind->dealloc_cache)
1819 fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1820 }
1821
1822 /* Since we can't really be sure what the first object allocated was. */
1823 obstack_free (&frame_cache_obstack, 0);
1824 obstack_init (&frame_cache_obstack);
1825
1826 if (sentinel_frame != NULL)
1827 annotate_frames_invalid ();
1828
1829 sentinel_frame = NULL; /* Invalidate cache */
1830 select_frame (NULL);
1831 frame_stash_invalidate ();
1832 if (frame_debug)
1833 fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1834 }
1835
1836 /* Find where a register is saved (in memory or another register).
1837 The result of frame_register_unwind is just where it is saved
1838 relative to this particular frame. */
1839
1840 static void
1841 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1842 int *optimizedp, enum lval_type *lvalp,
1843 CORE_ADDR *addrp, int *realnump)
1844 {
1845 gdb_assert (this_frame == NULL || this_frame->level >= 0);
1846
1847 while (this_frame != NULL)
1848 {
1849 int unavailable;
1850
1851 frame_register_unwind (this_frame, regnum, optimizedp, &unavailable,
1852 lvalp, addrp, realnump, NULL);
1853
1854 if (*optimizedp)
1855 break;
1856
1857 if (*lvalp != lval_register)
1858 break;
1859
1860 regnum = *realnump;
1861 this_frame = get_next_frame (this_frame);
1862 }
1863 }
1864
1865 /* Called during frame unwinding to remove a previous frame pointer from a
1866 frame passed in ARG. */
1867
1868 static void
1869 remove_prev_frame (void *arg)
1870 {
1871 struct frame_info *this_frame, *prev_frame;
1872
1873 this_frame = (struct frame_info *) arg;
1874 prev_frame = this_frame->prev;
1875 gdb_assert (prev_frame != NULL);
1876
1877 prev_frame->next = NULL;
1878 this_frame->prev = NULL;
1879 }
1880
1881 /* Get the previous raw frame, and check that it is not identical to
1882 same other frame frame already in the chain. If it is, there is
1883 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1884 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1885 validity tests, that compare THIS_FRAME and the next frame, we do
1886 this right after creating the previous frame, to avoid ever ending
1887 up with two frames with the same id in the frame chain. */
1888
1889 static struct frame_info *
1890 get_prev_frame_if_no_cycle (struct frame_info *this_frame)
1891 {
1892 struct frame_info *prev_frame;
1893 struct cleanup *prev_frame_cleanup;
1894
1895 prev_frame = get_prev_frame_raw (this_frame);
1896
1897 /* Don't compute the frame id of the current frame yet. Unwinding
1898 the sentinel frame can fail (e.g., if the thread is gone and we
1899 can't thus read its registers). If we let the cycle detection
1900 code below try to compute a frame ID, then an error thrown from
1901 within the frame ID computation would result in the sentinel
1902 frame as outermost frame, which is bogus. Instead, we'll compute
1903 the current frame's ID lazily in get_frame_id. Note that there's
1904 no point in doing cycle detection when there's only one frame, so
1905 nothing is lost here. */
1906 if (prev_frame->level == 0)
1907 return prev_frame;
1908
1909 /* The cleanup will remove the previous frame that get_prev_frame_raw
1910 linked onto THIS_FRAME. */
1911 prev_frame_cleanup = make_cleanup (remove_prev_frame, this_frame);
1912
1913 compute_frame_id (prev_frame);
1914 if (!frame_stash_add (prev_frame))
1915 {
1916 /* Another frame with the same id was already in the stash. We just
1917 detected a cycle. */
1918 if (frame_debug)
1919 {
1920 fprintf_unfiltered (gdb_stdlog, "-> ");
1921 fprint_frame (gdb_stdlog, NULL);
1922 fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1923 }
1924 this_frame->stop_reason = UNWIND_SAME_ID;
1925 /* Unlink. */
1926 prev_frame->next = NULL;
1927 this_frame->prev = NULL;
1928 prev_frame = NULL;
1929 }
1930
1931 discard_cleanups (prev_frame_cleanup);
1932 return prev_frame;
1933 }
1934
1935 /* Helper function for get_prev_frame_always, this is called inside a
1936 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1937 there is no such frame. This may throw an exception. */
1938
1939 static struct frame_info *
1940 get_prev_frame_always_1 (struct frame_info *this_frame)
1941 {
1942 struct gdbarch *gdbarch;
1943
1944 gdb_assert (this_frame != NULL);
1945 gdbarch = get_frame_arch (this_frame);
1946
1947 if (frame_debug)
1948 {
1949 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame=");
1950 if (this_frame != NULL)
1951 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1952 else
1953 fprintf_unfiltered (gdb_stdlog, "<NULL>");
1954 fprintf_unfiltered (gdb_stdlog, ") ");
1955 }
1956
1957 /* Only try to do the unwind once. */
1958 if (this_frame->prev_p)
1959 {
1960 if (frame_debug)
1961 {
1962 fprintf_unfiltered (gdb_stdlog, "-> ");
1963 fprint_frame (gdb_stdlog, this_frame->prev);
1964 fprintf_unfiltered (gdb_stdlog, " // cached \n");
1965 }
1966 return this_frame->prev;
1967 }
1968
1969 /* If the frame unwinder hasn't been selected yet, we must do so
1970 before setting prev_p; otherwise the check for misbehaved
1971 sniffers will think that this frame's sniffer tried to unwind
1972 further (see frame_cleanup_after_sniffer). */
1973 if (this_frame->unwind == NULL)
1974 frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1975
1976 this_frame->prev_p = 1;
1977 this_frame->stop_reason = UNWIND_NO_REASON;
1978
1979 /* If we are unwinding from an inline frame, all of the below tests
1980 were already performed when we unwound from the next non-inline
1981 frame. We must skip them, since we can not get THIS_FRAME's ID
1982 until we have unwound all the way down to the previous non-inline
1983 frame. */
1984 if (get_frame_type (this_frame) == INLINE_FRAME)
1985 return get_prev_frame_if_no_cycle (this_frame);
1986
1987 /* Check that this frame is unwindable. If it isn't, don't try to
1988 unwind to the prev frame. */
1989 this_frame->stop_reason
1990 = this_frame->unwind->stop_reason (this_frame,
1991 &this_frame->prologue_cache);
1992
1993 if (this_frame->stop_reason != UNWIND_NO_REASON)
1994 {
1995 if (frame_debug)
1996 {
1997 enum unwind_stop_reason reason = this_frame->stop_reason;
1998
1999 fprintf_unfiltered (gdb_stdlog, "-> ");
2000 fprint_frame (gdb_stdlog, NULL);
2001 fprintf_unfiltered (gdb_stdlog, " // %s }\n",
2002 frame_stop_reason_symbol_string (reason));
2003 }
2004 return NULL;
2005 }
2006
2007 /* Check that this frame's ID isn't inner to (younger, below, next)
2008 the next frame. This happens when a frame unwind goes backwards.
2009 This check is valid only if this frame and the next frame are NORMAL.
2010 See the comment at frame_id_inner for details. */
2011 if (get_frame_type (this_frame) == NORMAL_FRAME
2012 && this_frame->next->unwind->type == NORMAL_FRAME
2013 && frame_id_inner (get_frame_arch (this_frame->next),
2014 get_frame_id (this_frame),
2015 get_frame_id (this_frame->next)))
2016 {
2017 CORE_ADDR this_pc_in_block;
2018 struct minimal_symbol *morestack_msym;
2019 const char *morestack_name = NULL;
2020
2021 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2022 this_pc_in_block = get_frame_address_in_block (this_frame);
2023 morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
2024 if (morestack_msym)
2025 morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
2026 if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
2027 {
2028 if (frame_debug)
2029 {
2030 fprintf_unfiltered (gdb_stdlog, "-> ");
2031 fprint_frame (gdb_stdlog, NULL);
2032 fprintf_unfiltered (gdb_stdlog,
2033 " // this frame ID is inner }\n");
2034 }
2035 this_frame->stop_reason = UNWIND_INNER_ID;
2036 return NULL;
2037 }
2038 }
2039
2040 /* Check that this and the next frame do not unwind the PC register
2041 to the same memory location. If they do, then even though they
2042 have different frame IDs, the new frame will be bogus; two
2043 functions can't share a register save slot for the PC. This can
2044 happen when the prologue analyzer finds a stack adjustment, but
2045 no PC save.
2046
2047 This check does assume that the "PC register" is roughly a
2048 traditional PC, even if the gdbarch_unwind_pc method adjusts
2049 it (we do not rely on the value, only on the unwound PC being
2050 dependent on this value). A potential improvement would be
2051 to have the frame prev_pc method and the gdbarch unwind_pc
2052 method set the same lval and location information as
2053 frame_register_unwind. */
2054 if (this_frame->level > 0
2055 && gdbarch_pc_regnum (gdbarch) >= 0
2056 && get_frame_type (this_frame) == NORMAL_FRAME
2057 && (get_frame_type (this_frame->next) == NORMAL_FRAME
2058 || get_frame_type (this_frame->next) == INLINE_FRAME))
2059 {
2060 int optimized, realnum, nrealnum;
2061 enum lval_type lval, nlval;
2062 CORE_ADDR addr, naddr;
2063
2064 frame_register_unwind_location (this_frame,
2065 gdbarch_pc_regnum (gdbarch),
2066 &optimized, &lval, &addr, &realnum);
2067 frame_register_unwind_location (get_next_frame (this_frame),
2068 gdbarch_pc_regnum (gdbarch),
2069 &optimized, &nlval, &naddr, &nrealnum);
2070
2071 if ((lval == lval_memory && lval == nlval && addr == naddr)
2072 || (lval == lval_register && lval == nlval && realnum == nrealnum))
2073 {
2074 if (frame_debug)
2075 {
2076 fprintf_unfiltered (gdb_stdlog, "-> ");
2077 fprint_frame (gdb_stdlog, NULL);
2078 fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
2079 }
2080
2081 this_frame->stop_reason = UNWIND_NO_SAVED_PC;
2082 this_frame->prev = NULL;
2083 return NULL;
2084 }
2085 }
2086
2087 return get_prev_frame_if_no_cycle (this_frame);
2088 }
2089
2090 /* Return a "struct frame_info" corresponding to the frame that called
2091 THIS_FRAME. Returns NULL if there is no such frame.
2092
2093 Unlike get_prev_frame, this function always tries to unwind the
2094 frame. */
2095
2096 struct frame_info *
2097 get_prev_frame_always (struct frame_info *this_frame)
2098 {
2099 struct frame_info *prev_frame = NULL;
2100
2101 TRY
2102 {
2103 prev_frame = get_prev_frame_always_1 (this_frame);
2104 }
2105 CATCH (ex, RETURN_MASK_ERROR)
2106 {
2107 if (ex.error == MEMORY_ERROR)
2108 {
2109 this_frame->stop_reason = UNWIND_MEMORY_ERROR;
2110 if (ex.message != NULL)
2111 {
2112 char *stop_string;
2113 size_t size;
2114
2115 /* The error needs to live as long as the frame does.
2116 Allocate using stack local STOP_STRING then assign the
2117 pointer to the frame, this allows the STOP_STRING on the
2118 frame to be of type 'const char *'. */
2119 size = strlen (ex.message) + 1;
2120 stop_string = (char *) frame_obstack_zalloc (size);
2121 memcpy (stop_string, ex.message, size);
2122 this_frame->stop_string = stop_string;
2123 }
2124 prev_frame = NULL;
2125 }
2126 else
2127 throw_exception (ex);
2128 }
2129 END_CATCH
2130
2131 return prev_frame;
2132 }
2133
2134 /* Construct a new "struct frame_info" and link it previous to
2135 this_frame. */
2136
2137 static struct frame_info *
2138 get_prev_frame_raw (struct frame_info *this_frame)
2139 {
2140 struct frame_info *prev_frame;
2141
2142 /* Allocate the new frame but do not wire it in to the frame chain.
2143 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2144 frame->next to pull some fancy tricks (of course such code is, by
2145 definition, recursive). Try to prevent it.
2146
2147 There is no reason to worry about memory leaks, should the
2148 remainder of the function fail. The allocated memory will be
2149 quickly reclaimed when the frame cache is flushed, and the `we've
2150 been here before' check above will stop repeated memory
2151 allocation calls. */
2152 prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
2153 prev_frame->level = this_frame->level + 1;
2154
2155 /* For now, assume we don't have frame chains crossing address
2156 spaces. */
2157 prev_frame->pspace = this_frame->pspace;
2158 prev_frame->aspace = this_frame->aspace;
2159
2160 /* Don't yet compute ->unwind (and hence ->type). It is computed
2161 on-demand in get_frame_type, frame_register_unwind, and
2162 get_frame_id. */
2163
2164 /* Don't yet compute the frame's ID. It is computed on-demand by
2165 get_frame_id(). */
2166
2167 /* The unwound frame ID is validate at the start of this function,
2168 as part of the logic to decide if that frame should be further
2169 unwound, and not here while the prev frame is being created.
2170 Doing this makes it possible for the user to examine a frame that
2171 has an invalid frame ID.
2172
2173 Some very old VAX code noted: [...] For the sake of argument,
2174 suppose that the stack is somewhat trashed (which is one reason
2175 that "info frame" exists). So, return 0 (indicating we don't
2176 know the address of the arglist) if we don't know what frame this
2177 frame calls. */
2178
2179 /* Link it in. */
2180 this_frame->prev = prev_frame;
2181 prev_frame->next = this_frame;
2182
2183 if (frame_debug)
2184 {
2185 fprintf_unfiltered (gdb_stdlog, "-> ");
2186 fprint_frame (gdb_stdlog, prev_frame);
2187 fprintf_unfiltered (gdb_stdlog, " }\n");
2188 }
2189
2190 return prev_frame;
2191 }
2192
2193 /* Debug routine to print a NULL frame being returned. */
2194
2195 static void
2196 frame_debug_got_null_frame (struct frame_info *this_frame,
2197 const char *reason)
2198 {
2199 if (frame_debug)
2200 {
2201 fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
2202 if (this_frame != NULL)
2203 fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
2204 else
2205 fprintf_unfiltered (gdb_stdlog, "<NULL>");
2206 fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
2207 }
2208 }
2209
2210 /* Is this (non-sentinel) frame in the "main"() function? */
2211
2212 static int
2213 inside_main_func (struct frame_info *this_frame)
2214 {
2215 struct bound_minimal_symbol msymbol;
2216 CORE_ADDR maddr;
2217
2218 if (symfile_objfile == 0)
2219 return 0;
2220 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
2221 if (msymbol.minsym == NULL)
2222 return 0;
2223 /* Make certain that the code, and not descriptor, address is
2224 returned. */
2225 maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
2226 BMSYMBOL_VALUE_ADDRESS (msymbol),
2227 &current_target);
2228 return maddr == get_frame_func (this_frame);
2229 }
2230
2231 /* Test whether THIS_FRAME is inside the process entry point function. */
2232
2233 static int
2234 inside_entry_func (struct frame_info *this_frame)
2235 {
2236 CORE_ADDR entry_point;
2237
2238 if (!entry_point_address_query (&entry_point))
2239 return 0;
2240
2241 return get_frame_func (this_frame) == entry_point;
2242 }
2243
2244 /* Return a structure containing various interesting information about
2245 the frame that called THIS_FRAME. Returns NULL if there is entier
2246 no such frame or the frame fails any of a set of target-independent
2247 condition that should terminate the frame chain (e.g., as unwinding
2248 past main()).
2249
2250 This function should not contain target-dependent tests, such as
2251 checking whether the program-counter is zero. */
2252
2253 struct frame_info *
2254 get_prev_frame (struct frame_info *this_frame)
2255 {
2256 CORE_ADDR frame_pc;
2257 int frame_pc_p;
2258
2259 /* There is always a frame. If this assertion fails, suspect that
2260 something should be calling get_selected_frame() or
2261 get_current_frame(). */
2262 gdb_assert (this_frame != NULL);
2263
2264 /* If this_frame is the current frame, then compute and stash
2265 its frame id prior to fetching and computing the frame id of the
2266 previous frame. Otherwise, the cycle detection code in
2267 get_prev_frame_if_no_cycle() will not work correctly. When
2268 get_frame_id() is called later on, an assertion error will
2269 be triggered in the event of a cycle between the current
2270 frame and its previous frame. */
2271 if (this_frame->level == 0)
2272 get_frame_id (this_frame);
2273
2274 frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);
2275
2276 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2277 sense to stop unwinding at a dummy frame. One place where a dummy
2278 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2279 pcsqh register (space register for the instruction at the head of the
2280 instruction queue) cannot be written directly; the only way to set it
2281 is to branch to code that is in the target space. In order to implement
2282 frame dummies on HPUX, the called function is made to jump back to where
2283 the inferior was when the user function was called. If gdb was inside
2284 the main function when we created the dummy frame, the dummy frame will
2285 point inside the main function. */
2286 if (this_frame->level >= 0
2287 && get_frame_type (this_frame) == NORMAL_FRAME
2288 && !backtrace_past_main
2289 && frame_pc_p
2290 && inside_main_func (this_frame))
2291 /* Don't unwind past main(). Note, this is done _before_ the
2292 frame has been marked as previously unwound. That way if the
2293 user later decides to enable unwinds past main(), that will
2294 automatically happen. */
2295 {
2296 frame_debug_got_null_frame (this_frame, "inside main func");
2297 return NULL;
2298 }
2299
2300 /* If the user's backtrace limit has been exceeded, stop. We must
2301 add two to the current level; one of those accounts for backtrace_limit
2302 being 1-based and the level being 0-based, and the other accounts for
2303 the level of the new frame instead of the level of the current
2304 frame. */
2305 if (this_frame->level + 2 > backtrace_limit)
2306 {
2307 frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
2308 return NULL;
2309 }
2310
2311 /* If we're already inside the entry function for the main objfile,
2312 then it isn't valid. Don't apply this test to a dummy frame -
2313 dummy frame PCs typically land in the entry func. Don't apply
2314 this test to the sentinel frame. Sentinel frames should always
2315 be allowed to unwind. */
2316 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2317 wasn't checking for "main" in the minimal symbols. With that
2318 fixed asm-source tests now stop in "main" instead of halting the
2319 backtrace in weird and wonderful ways somewhere inside the entry
2320 file. Suspect that tests for inside the entry file/func were
2321 added to work around that (now fixed) case. */
2322 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2323 suggested having the inside_entry_func test use the
2324 inside_main_func() msymbol trick (along with entry_point_address()
2325 I guess) to determine the address range of the start function.
2326 That should provide a far better stopper than the current
2327 heuristics. */
2328 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2329 applied tail-call optimizations to main so that a function called
2330 from main returns directly to the caller of main. Since we don't
2331 stop at main, we should at least stop at the entry point of the
2332 application. */
2333 if (this_frame->level >= 0
2334 && get_frame_type (this_frame) == NORMAL_FRAME
2335 && !backtrace_past_entry
2336 && frame_pc_p
2337 && inside_entry_func (this_frame))
2338 {
2339 frame_debug_got_null_frame (this_frame, "inside entry func");
2340 return NULL;
2341 }
2342
2343 /* Assume that the only way to get a zero PC is through something
2344 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2345 will never unwind a zero PC. */
2346 if (this_frame->level > 0
2347 && (get_frame_type (this_frame) == NORMAL_FRAME
2348 || get_frame_type (this_frame) == INLINE_FRAME)
2349 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
2350 && frame_pc_p && frame_pc == 0)
2351 {
2352 frame_debug_got_null_frame (this_frame, "zero PC");
2353 return NULL;
2354 }
2355
2356 return get_prev_frame_always (this_frame);
2357 }
2358
2359 struct frame_id
2360 get_prev_frame_id_by_id (struct frame_id id)
2361 {
2362 struct frame_id prev_id;
2363 struct frame_info *frame;
2364
2365 frame = frame_find_by_id (id);
2366
2367 if (frame != NULL)
2368 prev_id = get_frame_id (get_prev_frame (frame));
2369 else
2370 prev_id = null_frame_id;
2371
2372 return prev_id;
2373 }
2374
2375 CORE_ADDR
2376 get_frame_pc (struct frame_info *frame)
2377 {
2378 gdb_assert (frame->next != NULL);
2379 return frame_unwind_pc (frame->next);
2380 }
2381
2382 int
2383 get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
2384 {
2385
2386 gdb_assert (frame->next != NULL);
2387
2388 TRY
2389 {
2390 *pc = frame_unwind_pc (frame->next);
2391 }
2392 CATCH (ex, RETURN_MASK_ERROR)
2393 {
2394 if (ex.error == NOT_AVAILABLE_ERROR)
2395 return 0;
2396 else
2397 throw_exception (ex);
2398 }
2399 END_CATCH
2400
2401 return 1;
2402 }
2403
2404 /* Return an address that falls within THIS_FRAME's code block. */
2405
2406 CORE_ADDR
2407 get_frame_address_in_block (struct frame_info *this_frame)
2408 {
2409 /* A draft address. */
2410 CORE_ADDR pc = get_frame_pc (this_frame);
2411
2412 struct frame_info *next_frame = this_frame->next;
2413
2414 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2415 Normally the resume address is inside the body of the function
2416 associated with THIS_FRAME, but there is a special case: when
2417 calling a function which the compiler knows will never return
2418 (for instance abort), the call may be the very last instruction
2419 in the calling function. The resume address will point after the
2420 call and may be at the beginning of a different function
2421 entirely.
2422
2423 If THIS_FRAME is a signal frame or dummy frame, then we should
2424 not adjust the unwound PC. For a dummy frame, GDB pushed the
2425 resume address manually onto the stack. For a signal frame, the
2426 OS may have pushed the resume address manually and invoked the
2427 handler (e.g. GNU/Linux), or invoked the trampoline which called
2428 the signal handler - but in either case the signal handler is
2429 expected to return to the trampoline. So in both of these
2430 cases we know that the resume address is executable and
2431 related. So we only need to adjust the PC if THIS_FRAME
2432 is a normal function.
2433
2434 If the program has been interrupted while THIS_FRAME is current,
2435 then clearly the resume address is inside the associated
2436 function. There are three kinds of interruption: debugger stop
2437 (next frame will be SENTINEL_FRAME), operating system
2438 signal or exception (next frame will be SIGTRAMP_FRAME),
2439 or debugger-induced function call (next frame will be
2440 DUMMY_FRAME). So we only need to adjust the PC if
2441 NEXT_FRAME is a normal function.
2442
2443 We check the type of NEXT_FRAME first, since it is already
2444 known; frame type is determined by the unwinder, and since
2445 we have THIS_FRAME we've already selected an unwinder for
2446 NEXT_FRAME.
2447
2448 If the next frame is inlined, we need to keep going until we find
2449 the real function - for instance, if a signal handler is invoked
2450 while in an inlined function, then the code address of the
2451 "calling" normal function should not be adjusted either. */
2452
2453 while (get_frame_type (next_frame) == INLINE_FRAME)
2454 next_frame = next_frame->next;
2455
2456 if ((get_frame_type (next_frame) == NORMAL_FRAME
2457 || get_frame_type (next_frame) == TAILCALL_FRAME)
2458 && (get_frame_type (this_frame) == NORMAL_FRAME
2459 || get_frame_type (this_frame) == TAILCALL_FRAME
2460 || get_frame_type (this_frame) == INLINE_FRAME))
2461 return pc - 1;
2462
2463 return pc;
2464 }
2465
2466 int
2467 get_frame_address_in_block_if_available (struct frame_info *this_frame,
2468 CORE_ADDR *pc)
2469 {
2470
2471 TRY
2472 {
2473 *pc = get_frame_address_in_block (this_frame);
2474 }
2475 CATCH (ex, RETURN_MASK_ERROR)
2476 {
2477 if (ex.error == NOT_AVAILABLE_ERROR)
2478 return 0;
2479 throw_exception (ex);
2480 }
2481 END_CATCH
2482
2483 return 1;
2484 }
2485
2486 symtab_and_line
2487 find_frame_sal (frame_info *frame)
2488 {
2489 struct frame_info *next_frame;
2490 int notcurrent;
2491 CORE_ADDR pc;
2492
2493 /* If the next frame represents an inlined function call, this frame's
2494 sal is the "call site" of that inlined function, which can not
2495 be inferred from get_frame_pc. */
2496 next_frame = get_next_frame (frame);
2497 if (frame_inlined_callees (frame) > 0)
2498 {
2499 struct symbol *sym;
2500
2501 if (next_frame)
2502 sym = get_frame_function (next_frame);
2503 else
2504 sym = inline_skipped_symbol (inferior_ptid);
2505
2506 /* If frame is inline, it certainly has symbols. */
2507 gdb_assert (sym);
2508
2509 symtab_and_line sal;
2510 if (SYMBOL_LINE (sym) != 0)
2511 {
2512 sal.symtab = symbol_symtab (sym);
2513 sal.line = SYMBOL_LINE (sym);
2514 }
2515 else
2516 /* If the symbol does not have a location, we don't know where
2517 the call site is. Do not pretend to. This is jarring, but
2518 we can't do much better. */
2519 sal.pc = get_frame_pc (frame);
2520
2521 sal.pspace = get_frame_program_space (frame);
2522 return sal;
2523 }
2524
2525 /* If FRAME is not the innermost frame, that normally means that
2526 FRAME->pc points at the return instruction (which is *after* the
2527 call instruction), and we want to get the line containing the
2528 call (because the call is where the user thinks the program is).
2529 However, if the next frame is either a SIGTRAMP_FRAME or a
2530 DUMMY_FRAME, then the next frame will contain a saved interrupt
2531 PC and such a PC indicates the current (rather than next)
2532 instruction/line, consequently, for such cases, want to get the
2533 line containing fi->pc. */
2534 if (!get_frame_pc_if_available (frame, &pc))
2535 return {};
2536
2537 notcurrent = (pc != get_frame_address_in_block (frame));
2538 return find_pc_line (pc, notcurrent);
2539 }
2540
2541 /* Per "frame.h", return the ``address'' of the frame. Code should
2542 really be using get_frame_id(). */
2543 CORE_ADDR
2544 get_frame_base (struct frame_info *fi)
2545 {
2546 return get_frame_id (fi).stack_addr;
2547 }
2548
2549 /* High-level offsets into the frame. Used by the debug info. */
2550
2551 CORE_ADDR
2552 get_frame_base_address (struct frame_info *fi)
2553 {
2554 if (get_frame_type (fi) != NORMAL_FRAME)
2555 return 0;
2556 if (fi->base == NULL)
2557 fi->base = frame_base_find_by_frame (fi);
2558 /* Sneaky: If the low-level unwind and high-level base code share a
2559 common unwinder, let them share the prologue cache. */
2560 if (fi->base->unwind == fi->unwind)
2561 return fi->base->this_base (fi, &fi->prologue_cache);
2562 return fi->base->this_base (fi, &fi->base_cache);
2563 }
2564
2565 CORE_ADDR
2566 get_frame_locals_address (struct frame_info *fi)
2567 {
2568 if (get_frame_type (fi) != NORMAL_FRAME)
2569 return 0;
2570 /* If there isn't a frame address method, find it. */
2571 if (fi->base == NULL)
2572 fi->base = frame_base_find_by_frame (fi);
2573 /* Sneaky: If the low-level unwind and high-level base code share a
2574 common unwinder, let them share the prologue cache. */
2575 if (fi->base->unwind == fi->unwind)
2576 return fi->base->this_locals (fi, &fi->prologue_cache);
2577 return fi->base->this_locals (fi, &fi->base_cache);
2578 }
2579
2580 CORE_ADDR
2581 get_frame_args_address (struct frame_info *fi)
2582 {
2583 if (get_frame_type (fi) != NORMAL_FRAME)
2584 return 0;
2585 /* If there isn't a frame address method, find it. */
2586 if (fi->base == NULL)
2587 fi->base = frame_base_find_by_frame (fi);
2588 /* Sneaky: If the low-level unwind and high-level base code share a
2589 common unwinder, let them share the prologue cache. */
2590 if (fi->base->unwind == fi->unwind)
2591 return fi->base->this_args (fi, &fi->prologue_cache);
2592 return fi->base->this_args (fi, &fi->base_cache);
2593 }
2594
2595 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2596 otherwise. */
2597
2598 int
2599 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
2600 {
2601 if (fi->unwind == NULL)
2602 frame_unwind_find_by_frame (fi, &fi->prologue_cache);
2603 return fi->unwind == unwinder;
2604 }
2605
2606 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2607 or -1 for a NULL frame. */
2608
2609 int
2610 frame_relative_level (struct frame_info *fi)
2611 {
2612 if (fi == NULL)
2613 return -1;
2614 else
2615 return fi->level;
2616 }
2617
2618 enum frame_type
2619 get_frame_type (struct frame_info *frame)
2620 {
2621 if (frame->unwind == NULL)
2622 /* Initialize the frame's unwinder because that's what
2623 provides the frame's type. */
2624 frame_unwind_find_by_frame (frame, &frame->prologue_cache);
2625 return frame->unwind->type;
2626 }
2627
2628 struct program_space *
2629 get_frame_program_space (struct frame_info *frame)
2630 {
2631 return frame->pspace;
2632 }
2633
2634 struct program_space *
2635 frame_unwind_program_space (struct frame_info *this_frame)
2636 {
2637 gdb_assert (this_frame);
2638
2639 /* This is really a placeholder to keep the API consistent --- we
2640 assume for now that we don't have frame chains crossing
2641 spaces. */
2642 return this_frame->pspace;
2643 }
2644
2645 const address_space *
2646 get_frame_address_space (struct frame_info *frame)
2647 {
2648 return frame->aspace;
2649 }
2650
2651 /* Memory access methods. */
2652
2653 void
2654 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2655 gdb_byte *buf, int len)
2656 {
2657 read_memory (addr, buf, len);
2658 }
2659
2660 LONGEST
2661 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2662 int len)
2663 {
2664 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2665 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2666
2667 return read_memory_integer (addr, len, byte_order);
2668 }
2669
2670 ULONGEST
2671 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2672 int len)
2673 {
2674 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2675 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2676
2677 return read_memory_unsigned_integer (addr, len, byte_order);
2678 }
2679
2680 int
2681 safe_frame_unwind_memory (struct frame_info *this_frame,
2682 CORE_ADDR addr, gdb_byte *buf, int len)
2683 {
2684 /* NOTE: target_read_memory returns zero on success! */
2685 return !target_read_memory (addr, buf, len);
2686 }
2687
2688 /* Architecture methods. */
2689
2690 struct gdbarch *
2691 get_frame_arch (struct frame_info *this_frame)
2692 {
2693 return frame_unwind_arch (this_frame->next);
2694 }
2695
2696 struct gdbarch *
2697 frame_unwind_arch (struct frame_info *next_frame)
2698 {
2699 if (!next_frame->prev_arch.p)
2700 {
2701 struct gdbarch *arch;
2702
2703 if (next_frame->unwind == NULL)
2704 frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2705
2706 if (next_frame->unwind->prev_arch != NULL)
2707 arch = next_frame->unwind->prev_arch (next_frame,
2708 &next_frame->prologue_cache);
2709 else
2710 arch = get_frame_arch (next_frame);
2711
2712 next_frame->prev_arch.arch = arch;
2713 next_frame->prev_arch.p = 1;
2714 if (frame_debug)
2715 fprintf_unfiltered (gdb_stdlog,
2716 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2717 next_frame->level,
2718 gdbarch_bfd_arch_info (arch)->printable_name);
2719 }
2720
2721 return next_frame->prev_arch.arch;
2722 }
2723
2724 struct gdbarch *
2725 frame_unwind_caller_arch (struct frame_info *next_frame)
2726 {
2727 next_frame = skip_artificial_frames (next_frame);
2728
2729 /* We must have a non-artificial frame. The caller is supposed to check
2730 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2731 in this case. */
2732 gdb_assert (next_frame != NULL);
2733
2734 return frame_unwind_arch (next_frame);
2735 }
2736
2737 /* Gets the language of FRAME. */
2738
2739 enum language
2740 get_frame_language (struct frame_info *frame)
2741 {
2742 CORE_ADDR pc = 0;
2743 int pc_p = 0;
2744
2745 gdb_assert (frame!= NULL);
2746
2747 /* We determine the current frame language by looking up its
2748 associated symtab. To retrieve this symtab, we use the frame
2749 PC. However we cannot use the frame PC as is, because it
2750 usually points to the instruction following the "call", which
2751 is sometimes the first instruction of another function. So
2752 we rely on get_frame_address_in_block(), it provides us with
2753 a PC that is guaranteed to be inside the frame's code
2754 block. */
2755
2756 TRY
2757 {
2758 pc = get_frame_address_in_block (frame);
2759 pc_p = 1;
2760 }
2761 CATCH (ex, RETURN_MASK_ERROR)
2762 {
2763 if (ex.error != NOT_AVAILABLE_ERROR)
2764 throw_exception (ex);
2765 }
2766 END_CATCH
2767
2768 if (pc_p)
2769 {
2770 struct compunit_symtab *cust = find_pc_compunit_symtab (pc);
2771
2772 if (cust != NULL)
2773 return compunit_language (cust);
2774 }
2775
2776 return language_unknown;
2777 }
2778
2779 /* Stack pointer methods. */
2780
2781 CORE_ADDR
2782 get_frame_sp (struct frame_info *this_frame)
2783 {
2784 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2785
2786 /* Normality - an architecture that provides a way of obtaining any
2787 frame inner-most address. */
2788 if (gdbarch_unwind_sp_p (gdbarch))
2789 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2790 operate on THIS_FRAME now. */
2791 return gdbarch_unwind_sp (gdbarch, this_frame->next);
2792 /* Now things are really are grim. Hope that the value returned by
2793 the gdbarch_sp_regnum register is meaningful. */
2794 if (gdbarch_sp_regnum (gdbarch) >= 0)
2795 return get_frame_register_unsigned (this_frame,
2796 gdbarch_sp_regnum (gdbarch));
2797 internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2798 }
2799
2800 /* Return the reason why we can't unwind past FRAME. */
2801
2802 enum unwind_stop_reason
2803 get_frame_unwind_stop_reason (struct frame_info *frame)
2804 {
2805 /* Fill-in STOP_REASON. */
2806 get_prev_frame_always (frame);
2807 gdb_assert (frame->prev_p);
2808
2809 return frame->stop_reason;
2810 }
2811
2812 /* Return a string explaining REASON. */
2813
2814 const char *
2815 unwind_stop_reason_to_string (enum unwind_stop_reason reason)
2816 {
2817 switch (reason)
2818 {
2819 #define SET(name, description) \
2820 case name: return _(description);
2821 #include "unwind_stop_reasons.def"
2822 #undef SET
2823
2824 default:
2825 internal_error (__FILE__, __LINE__,
2826 "Invalid frame stop reason");
2827 }
2828 }
2829
2830 const char *
2831 frame_stop_reason_string (struct frame_info *fi)
2832 {
2833 gdb_assert (fi->prev_p);
2834 gdb_assert (fi->prev == NULL);
2835
2836 /* Return the specific string if we have one. */
2837 if (fi->stop_string != NULL)
2838 return fi->stop_string;
2839
2840 /* Return the generic string if we have nothing better. */
2841 return unwind_stop_reason_to_string (fi->stop_reason);
2842 }
2843
2844 /* Return the enum symbol name of REASON as a string, to use in debug
2845 output. */
2846
2847 static const char *
2848 frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
2849 {
2850 switch (reason)
2851 {
2852 #define SET(name, description) \
2853 case name: return #name;
2854 #include "unwind_stop_reasons.def"
2855 #undef SET
2856
2857 default:
2858 internal_error (__FILE__, __LINE__,
2859 "Invalid frame stop reason");
2860 }
2861 }
2862
2863 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2864 FRAME. */
2865
2866 void
2867 frame_cleanup_after_sniffer (struct frame_info *frame)
2868 {
2869 /* The sniffer should not allocate a prologue cache if it did not
2870 match this frame. */
2871 gdb_assert (frame->prologue_cache == NULL);
2872
2873 /* No sniffer should extend the frame chain; sniff based on what is
2874 already certain. */
2875 gdb_assert (!frame->prev_p);
2876
2877 /* The sniffer should not check the frame's ID; that's circular. */
2878 gdb_assert (!frame->this_id.p);
2879
2880 /* Clear cached fields dependent on the unwinder.
2881
2882 The previous PC is independent of the unwinder, but the previous
2883 function is not (see get_frame_address_in_block). */
2884 frame->prev_func.p = 0;
2885 frame->prev_func.addr = 0;
2886
2887 /* Discard the unwinder last, so that we can easily find it if an assertion
2888 in this function triggers. */
2889 frame->unwind = NULL;
2890 }
2891
2892 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2893 If sniffing fails, the caller should be sure to call
2894 frame_cleanup_after_sniffer. */
2895
2896 void
2897 frame_prepare_for_sniffer (struct frame_info *frame,
2898 const struct frame_unwind *unwind)
2899 {
2900 gdb_assert (frame->unwind == NULL);
2901 frame->unwind = unwind;
2902 }
2903
2904 static struct cmd_list_element *set_backtrace_cmdlist;
2905 static struct cmd_list_element *show_backtrace_cmdlist;
2906
2907 static void
2908 set_backtrace_cmd (const char *args, int from_tty)
2909 {
2910 help_list (set_backtrace_cmdlist, "set backtrace ", all_commands,
2911 gdb_stdout);
2912 }
2913
2914 static void
2915 show_backtrace_cmd (const char *args, int from_tty)
2916 {
2917 cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2918 }
2919
2920 void
2921 _initialize_frame (void)
2922 {
2923 obstack_init (&frame_cache_obstack);
2924
2925 frame_stash_create ();
2926
2927 observer_attach_target_changed (frame_observer_target_changed);
2928
2929 add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2930 Set backtrace specific variables.\n\
2931 Configure backtrace variables such as the backtrace limit"),
2932 &set_backtrace_cmdlist, "set backtrace ",
2933 0/*allow-unknown*/, &setlist);
2934 add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2935 Show backtrace specific variables\n\
2936 Show backtrace variables such as the backtrace limit"),
2937 &show_backtrace_cmdlist, "show backtrace ",
2938 0/*allow-unknown*/, &showlist);
2939
2940 add_setshow_boolean_cmd ("past-main", class_obscure,
2941 &backtrace_past_main, _("\
2942 Set whether backtraces should continue past \"main\"."), _("\
2943 Show whether backtraces should continue past \"main\"."), _("\
2944 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2945 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2946 of the stack trace."),
2947 NULL,
2948 show_backtrace_past_main,
2949 &set_backtrace_cmdlist,
2950 &show_backtrace_cmdlist);
2951
2952 add_setshow_boolean_cmd ("past-entry", class_obscure,
2953 &backtrace_past_entry, _("\
2954 Set whether backtraces should continue past the entry point of a program."),
2955 _("\
2956 Show whether backtraces should continue past the entry point of a program."),
2957 _("\
2958 Normally there are no callers beyond the entry point of a program, so GDB\n\
2959 will terminate the backtrace there. Set this variable if you need to see\n\
2960 the rest of the stack trace."),
2961 NULL,
2962 show_backtrace_past_entry,
2963 &set_backtrace_cmdlist,
2964 &show_backtrace_cmdlist);
2965
2966 add_setshow_uinteger_cmd ("limit", class_obscure,
2967 &backtrace_limit, _("\
2968 Set an upper bound on the number of backtrace levels."), _("\
2969 Show the upper bound on the number of backtrace levels."), _("\
2970 No more than the specified number of frames can be displayed or examined.\n\
2971 Literal \"unlimited\" or zero means no limit."),
2972 NULL,
2973 show_backtrace_limit,
2974 &set_backtrace_cmdlist,
2975 &show_backtrace_cmdlist);
2976
2977 /* Debug this files internals. */
2978 add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug, _("\
2979 Set frame debugging."), _("\
2980 Show frame debugging."), _("\
2981 When non-zero, frame specific internal debugging is enabled."),
2982 NULL,
2983 show_frame_debug,
2984 &setdebuglist, &showdebuglist);
2985 }
frame_id_p
int frame_id_p(struct frame_id l)
Definition: frame.c:646
gdbarch
Definition: gdbarch.c:127
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
frame_stash_invalidate
static void frame_stash_invalidate(void)
Definition: frame.c:267
get_frame_address_in_block_if_available
int get_frame_address_in_block_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:2467
MEMORY_ERROR
Definition: common-exceptions.h:78
user_reg_map_regnum_to_name
const char * user_reg_map_regnum_to_name(struct gdbarch *gdbarch, int regnum)
Definition: user-regs.c:193
frame_id::special_addr_p
unsigned int special_addr_p
Definition: frame.h:158
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
frame_id::special_addr
CORE_ADDR special_addr
Definition: frame.h:153
frame_stash_find
static struct frame_info * frame_stash_find(struct frame_id id)
Definition: frame.c:252
main_name
char * main_name(void)
Definition: symtab.c:5568
target_has_registers
#define target_has_registers
Definition: target.h:1740
show_backtrace_cmdlist
static struct cmd_list_element * show_backtrace_cmdlist
Definition: frame.c:2905
frame_addr_hash
static hashval_t frame_addr_hash(const void *ap)
Definition: frame.c:172
SENTINEL_FRAME
Definition: frame.h:260
CC_UNKNOWN
Definition: frame.c:63
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
gdb_obstack.h
get_frame_address_in_block
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2407
sentinel_frame_id
const struct frame_id sentinel_frame_id
Definition: frame.c:576
REG_VALID
Definition: common-regcache.h:32
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
frame_id::stack_status
__extension__ enum frame_id_stack_status stack_status
Definition: frame.h:156
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
selected_frame
static struct frame_info * selected_frame
Definition: frame.c:1606
frame_unwind::type
enum frame_type type
Definition: frame-unwind.h:148
skip_artificial_frames
static struct frame_info * skip_artificial_frames(struct frame_info *frame)
Definition: frame.c:438
command.h
frame_id::code_addr
CORE_ADDR code_addr
Definition: frame.h:141
ARCH_FRAME
Definition: frame.h:257
backtrace_limit
static unsigned int backtrace_limit
Definition: frame.c:305
gdbarch_inner_than
int gdbarch_inner_than(struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
Definition: gdbarch.c:2827
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
frame_info::arch
struct gdbarch * arch
Definition: frame.c:116
frame_pop
void frame_pop(struct frame_info *this_frame)
Definition: frame.c:1031
cmd_list_element
Definition: cli-decode.h:46
frame_unwind_caller_pc
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:944
frame_unwind_caller_arch
struct gdbarch * frame_unwind_caller_arch(struct frame_info *next_frame)
Definition: frame.c:2725
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
frame_info::prev_p
int prev_p
Definition: frame.c:148
dummy_frame_pop
void dummy_frame_pop(struct frame_id dummy_id, ptid_t ptid)
Definition: dummy-frame.c:205
sentinel_frame_cache
void * sentinel_frame_cache(struct regcache *regcache)
Definition: sentinel-frame.c:33
set_language
enum language set_language(enum language lang)
Definition: language.c:379
put_frame_register_bytes
void put_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, const gdb_byte *myaddr)
Definition: frame.c:1470
frame_base::this_locals
frame_this_locals_ftype * this_locals
Definition: frame-base.h:64
frame_stop_reason_string
const char * frame_stop_reason_string(struct frame_info *fi)
Definition: frame.c:2831
lval_register
Definition: defs.h:385
frame_unwind_register_unsigned
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1279
frame_id_inner
static int frame_id_inner(struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
Definition: frame.c:754
frame_cleanup_after_sniffer
void frame_cleanup_after_sniffer(struct frame_info *frame)
Definition: frame.c:2867
val_print_unavailable
void val_print_unavailable(struct ui_file *stream)
Definition: valprint.c:368
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
frame_info::p
int p
Definition: frame.c:115
frame_id_build_unavailable_stack
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
Definition: frame.c:597
get_frame_sp
CORE_ADDR get_frame_sp(struct frame_info *this_frame)
Definition: frame.c:2782
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
get_stack_frame_id
struct frame_id get_stack_frame_id(struct frame_info *next_frame)
Definition: frame.c:549
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
null_frame_id
const struct frame_id null_frame_id
Definition: frame.c:575
frame_unwind_register
void frame_unwind_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1145
frame_debug_got_null_frame
static void frame_debug_got_null_frame(struct frame_info *this_frame, const char *reason)
Definition: frame.c:2196
sentinel_frame_unwind
const struct frame_unwind sentinel_frame_unwind
Definition: sentinel-frame.c:80
get_frame_pc_if_available
int get_frame_pc_if_available(struct frame_info *frame, CORE_ADDR *pc)
Definition: frame.c:2383
frame_unwind::prev_register
frame_prev_register_ftype * prev_register
Definition: frame-unwind.h:153
get_prev_frame_always_1
static struct frame_info * get_prev_frame_always_1(struct frame_info *this_frame)
Definition: frame.c:1940
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
FID_STACK_VALID
Definition: frame.h:91
value_free
void value_free(struct value *val)
Definition: value.c:1608
frame_info::status
enum cached_copy_status status
Definition: frame.c:121
SIGTRAMP_FRAME
Definition: frame.h:255
frame_info
Definition: frame.c:85
unwind_stop_reason
unwind_stop_reason
Definition: frame.h:504
frame_info::prev_arch
struct frame_info::@57 prev_arch
language_defn::la_language
enum language la_language
Definition: language.h:144
compunit_symtab
Definition: symtab.h:1380
frame_unwind::dealloc_cache
frame_dealloc_cache_ftype * dealloc_cache
Definition: frame-unwind.h:156
register_status
register_status
Definition: common-regcache.h:25
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
get_frame_memory_unsigned
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2671
ui_file
Definition: ui-file.h:26
backtrace_past_main
static int backtrace_past_main
Definition: frame.c:284
regcache_save
void regcache_save(struct regcache *regcache, regcache_cooked_read_ftype *cooked_read, void *src)
Definition: regcache.c:276
frame_prepare_for_sniffer
void frame_prepare_for_sniffer(struct frame_info *frame, const struct frame_unwind *unwind)
Definition: frame.c:2897
defs.h
lval_type
lval_type
Definition: defs.h:378
frame_info::pspace
struct program_space * pspace
Definition: frame.c:99
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
gdbarch_unwind_sp_p
int gdbarch_unwind_sp_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3086
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
frame_info::this_id
struct frame_info::@60 this_id
get_frame_locals_address
CORE_ADDR get_frame_locals_address(struct frame_info *fi)
Definition: frame.c:2566
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
get_prev_frame_id_by_id
struct frame_id get_prev_frame_id_by_id(struct frame_id id)
Definition: frame.c:2360
block_for_pc
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
FRAME_OBSTACK_ZALLOC
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:678
frame_stash_add
static int frame_stash_add(struct frame_info *frame)
Definition: frame.c:225
frame_info::value
CORE_ADDR value
Definition: frame.c:122
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
frame_unwind_arch
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
Definition: frame.c:2697
get_frame_address_space
const address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2646
observer.h
show_backtrace_cmd
static void show_backtrace_cmd(const char *args, int from_tty)
Definition: frame.c:2915
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
find_pc_compunit_symtab
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
Definition: symtab.c:2988
remove_prev_frame
static void remove_prev_frame(void *arg)
Definition: frame.c:1869
DUMMY_FRAME
Definition: frame.h:247
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
frame_unwind_find_by_frame
void frame_unwind_find_by_frame(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:143
value::lval
enum lval_type lval
Definition: value.c:173
NOT_AVAILABLE_ERROR
Definition: common-exceptions.h:82
gdbarch_num_pseudo_regs
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2057
frame_unwind_register_signed
LONGEST frame_unwind_register_signed(struct frame_info *frame, int regnum)
Definition: frame.c:1244
TRY
#define TRY
Definition: common-exceptions.h:246
CC_UNAVAILABLE
Definition: frame.c:72
frame_unwind_pc
static CORE_ADDR frame_unwind_pc(struct frame_info *this_frame)
Definition: frame.c:855
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
val_print_optimized_out
void val_print_optimized_out(const struct value *val, struct ui_file *stream)
Definition: valprint.c:353
frame_stash_create
static void frame_stash_create(void)
Definition: frame.c:212
unwind_stop_reason_to_string
const char * unwind_stop_reason_to_string(enum unwind_stop_reason reason)
Definition: frame.c:2815
lval_memory
Definition: defs.h:383
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
add_setshow_uinteger_cmd
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:723
name
const char *const name
Definition: aarch64-tdep.c:76
observer_attach_target_changed
struct observer * observer_attach_target_changed(observer_target_changed_ftype *f)
get_frame_type
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2619
frame_register
void frame_register(struct frame_info *frame, int regnum, int *optimizedp, int *unavailablep, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
Definition: frame.c:1125
get_frame_register_value
struct value * get_frame_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1238
inline-frame.h
fprint_frame
static void fprint_frame(struct ui_file *file, struct frame_info *fi)
Definition: frame.c:385
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
read_memory_integer
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:316
NORMAL_FRAME
Definition: frame.h:244
frame_info::level
int level
Definition: frame.c:96
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
contained_in
int contained_in(const struct block *a, const struct block *b)
Definition: block.c:73
frame_info::base_cache
void * base_cache
Definition: frame.c:143
current_target
struct target_ops current_target
frame_info::prologue_cache
void * prologue_cache
Definition: frame.c:109
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
frame_addr_hash_eq
static int frame_addr_hash_eq(const void *a, const void *b)
Definition: frame.c:199
gdbarch_sp_regnum
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2146
inline_skipped_symbol
struct symbol * inline_skipped_symbol(ptid_t ptid)
Definition: inline-frame.c:383
dummy-frame.h
UINT_MAX
#define UINT_MAX
Definition: defs.h:473
target_ops
Definition: target.h:412
get_frame_unwind_stop_reason
enum unwind_stop_reason get_frame_unwind_stop_reason(struct frame_info *frame)
Definition: frame.c:2803
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
safe_frame_unwind_memory
int safe_frame_unwind_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
Definition: frame.c:2681
frame_obstack_zalloc
void * frame_obstack_zalloc(unsigned long size)
Definition: frame.c:1552
regcache.h
frame_type
frame_type
Definition: frame.h:240
bound_minimal_symbol
Definition: minsyms.h:29
frame_info::prev_pc
struct frame_info::@58 prev_pc
gdbarch_convert_from_func_ptr_addr
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3191
frame_unwind::prev_arch
frame_prev_arch_ftype * prev_arch
Definition: frame-unwind.h:157
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
frame_unwind::stop_reason
frame_unwind_stop_reason_ftype * stop_reason
Definition: frame-unwind.h:151
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
frame_info::prev
struct frame_info * prev
Definition: frame.c:149
value_contents_all
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1265
show_backtrace_past_entry
static void show_backtrace_past_entry(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: frame.c:297
frame.h
gdbarch_unwind_pc
CORE_ADDR gdbarch_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: gdbarch.c:3069
frame_id_build_special
struct frame_id frame_id_build_special(CORE_ADDR stack_addr, CORE_ADDR code_addr, CORE_ADDR special_addr)
Definition: frame.c:580
inside_entry_func
static int inside_entry_func(struct frame_info *this_frame)
Definition: frame.c:2234
get_frame_function
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
gdbthread.h
get_traceframe_number
int get_traceframe_number(void)
Definition: tracepoint.c:2976
get_selected_frame_if_set
struct frame_info * get_selected_frame_if_set(void)
Definition: frame.c:1657
inferior.h
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
frame_id_artificial_p
int frame_id_artificial_p(struct frame_id l)
Definition: frame.c:665
deprecated_safe_get_selected_frame
struct frame_info * deprecated_safe_get_selected_frame(void)
Definition: frame.c:1667
type
Definition: gdbtypes.h:749
get_frame_register_signed
LONGEST get_frame_register_signed(struct frame_info *frame, int regnum)
Definition: frame.c:1273
VALUE_REGNUM
#define VALUE_REGNUM(val)
Definition: value.h:451
language.h
tracepoint.h
gdbarch_unwind_sp
CORE_ADDR gdbarch_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: gdbarch.c:3093
fprint_field
static void fprint_field(struct ui_file *file, const char *name, int p, CORE_ADDR addr)
Definition: frame.c:318
frame-unwind.h
get_prev_frame_always
struct frame_info * get_prev_frame_always(struct frame_info *this_frame)
Definition: frame.c:2097
value_contents_writeable
gdb_byte * value_contents_writeable(struct value *value)
Definition: value.c:1416
inside_main_func
static int inside_main_func(struct frame_info *this_frame)
Definition: frame.c:2213
FID_STACK_INVALID
Definition: frame.h:88
get_next_frame_sentinel_okay
struct frame_info * get_next_frame_sentinel_okay(struct frame_info *this_frame)
Definition: frame.c:1784
frame_id_build_unavailable_stack_special
struct frame_id frame_id_build_unavailable_stack_special(CORE_ADDR code_addr, CORE_ADDR special_addr)
Definition: frame.c:610
set_backtrace_cmd
static void set_backtrace_cmd(const char *args, int from_tty)
Definition: frame.c:2908
regcache_cpy
void regcache_cpy(struct regcache *dst, struct regcache *src)
Definition: regcache.c:342
SYMBOL_LINE
#define SYMBOL_LINE(symbol)
Definition: symtab.h:1162
dummy
unsigned dummy
Definition: go32-nat.c:1073
frame_unwind_program_space
struct program_space * frame_unwind_program_space(struct frame_info *this_frame)
Definition: frame.c:2635
symfile_objfile
#define symfile_objfile
Definition: progspace.h:227
language_mode
language_mode
Definition: language.h:468
create_new_frame
struct frame_info * create_new_frame(CORE_ADDR addr, CORE_ADDR pc)
Definition: frame.c:1722
get_frame_args_address
CORE_ADDR get_frame_args_address(struct frame_info *fi)
Definition: frame.c:2581
frame_id::stack_addr
CORE_ADDR stack_addr
Definition: frame.h:126
target_has_memory
#define target_has_memory
Definition: target.h:1729
regnum
int regnum
Definition: aarch64-tdep.c:77
frame_base
Definition: frame-base.h:58
frame_info::unwind
const struct frame_unwind * unwind
Definition: frame.c:110
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
frame_unwind_caller_id
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
Definition: frame.c:555
frame_unwind_register_value
struct value * frame_unwind_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1172
show_backtrace_past_main
static void show_backtrace_past_main(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: frame.c:286
get_frame_register_unsigned
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1308
gdb_print_host_address
#define gdb_print_host_address(ADDR, STREAM)
Definition: utils.h:438
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
frame_info::prev_func
struct frame_info::@59 prev_func
create_sentinel_frame
static struct frame_info * create_sentinel_frame(struct program_space *pspace, struct regcache *regcache)
Definition: frame.c:1517
frame-base.h
regcache::aspace
const address_space * aspace() const
Definition: regcache.h:257
cmd_show_list
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:657
frame_register_unwind_location
static void frame_register_unwind_location(struct frame_info *this_frame, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump)
Definition: frame.c:1841
CC_VALUE
Definition: frame.c:66
put_frame_register
void put_frame_register(struct frame_info *frame, int regnum, const gdb_byte *buf)
Definition: frame.c:1334
user-regs.h
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
value
Definition: value.c:169
find_frame_sal
symtab_and_line find_frame_sal(frame_info *frame)
Definition: frame.c:2487
hash
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
get_frame_base_address
CORE_ADDR get_frame_base_address(struct frame_info *fi)
Definition: frame.c:2552
frame_id::code_addr_p
unsigned int code_addr_p
Definition: frame.h:157
frame_cache_obstack
static struct obstack frame_cache_obstack
Definition: frame.c:1549
frame_info::aspace
const address_space * aspace
Definition: frame.c:102
frame_save_as_regcache
std::unique_ptr< struct regcache > frame_save_as_regcache(struct frame_info *this_frame)
Definition: frame.c:1021
frame_id::artificial_depth
int artificial_depth
Definition: frame.h:164
frame_observer_target_changed
static void frame_observer_target_changed(struct target_ops *target)
Definition: frame.c:1801
show_frame_debug
static void show_frame_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: frame.c:276
symtab_and_line
Definition: symtab.h:1746
frame_inlined_callees
int frame_inlined_callees(struct frame_info *this_frame)
Definition: inline-frame.c:396
skip_tailcall_frames
struct frame_info * skip_tailcall_frames(struct frame_info *frame)
Definition: frame.c:474
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
entry_point_address_query
int entry_point_address_query(CORE_ADDR *entry_p)
Definition: objfiles.c:454
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
get_next_frame
struct frame_info * get_next_frame(struct frame_info *this_frame)
Definition: frame.c:1771
get_frame_func_if_available
int get_frame_func_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:957
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
language_mode_auto
Definition: language.h:470
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
current_language
const struct language_defn * current_language
Definition: language.c:81
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
target_has_stack
#define target_has_stack
Definition: target.h:1735
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
INLINE_FRAME
Definition: frame.h:250
frame_info::stop_reason
enum unwind_stop_reason stop_reason
Definition: frame.c:153
_initialize_frame
void _initialize_frame(void)
Definition: frame.c:2921
get_frame_language
enum language get_frame_language(struct frame_info *frame)
Definition: frame.c:2740
address_space
Definition: progspace.h:216
deprecated_frame_register_read
int deprecated_frame_register_read(struct frame_info *frame, int regnum, gdb_byte *myaddr)
Definition: frame.c:1372
gdbcore.h
frame_relative_level
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2610
set_backtrace_cmdlist
static struct cmd_list_element * set_backtrace_cmdlist
Definition: frame.c:2904
FID_STACK_UNAVAILABLE
Definition: frame.h:99
get_frame_base
CORE_ADDR get_frame_base(struct frame_info *fi)
Definition: frame.c:2544
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
OPTIMIZED_OUT_ERROR
Definition: common-exceptions.h:86
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
show_backtrace_limit
static void show_backtrace_limit(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: frame.c:307
offset
int offset
Definition: agent.c:65
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
get_frame_register
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1165
frame_stash
static htab_t frame_stash
Definition: frame.c:165
read_frame_register_unsigned
int read_frame_register_unsigned(struct frame_info *frame, int regnum, ULONGEST *val)
Definition: frame.c:1314
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
frame_stop_reason_symbol_string
static const char * frame_stop_reason_symbol_string(enum unwind_stop_reason reason)
Definition: frame.c:2848
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
target.h
value.h
frame_unwind
Definition: frame-unwind.h:144
fprint_frame_id
void fprint_frame_id(struct ui_file *file, struct frame_id id)
Definition: frame.c:327
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
frame_register_unwind
void frame_register_unwind(struct frame_info *frame, int regnum, int *optimizedp, int *unavailablep, enum lval_type *lvalp, CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
Definition: frame.c:1081
frame_base::this_args
frame_this_args_ftype * this_args
Definition: frame-base.h:65
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
get_frame_register_bytes
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
Definition: frame.c:1388
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
fprint_frame_type
static void fprint_frame_type(struct ui_file *file, enum frame_type type)
Definition: frame.c:353
outer_frame_id
const struct frame_id outer_frame_id
Definition: frame.c:577
language
language
Definition: defs.h:203
release_value
void release_value(struct value *val)
Definition: value.c:1693
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
validate_registers_access
void validate_registers_access(void)
Definition: thread.c:1101
sentinel_frame
static struct frame_info * sentinel_frame
Definition: frame.c:53
cached_copy_status
cached_copy_status
Definition: frame.c:60
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
frame_info::addr
CORE_ADDR addr
Definition: frame.c:128
frame_info::base
const struct frame_base * base
Definition: frame.c:142
get_prev_frame_raw
static struct frame_info * get_prev_frame_raw(struct frame_info *this_frame)
Definition: frame.c:2138
symbol
Definition: symtab.h:1049
gdbarch_bfd_arch_info
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1500
frame_unwind::this_id
frame_this_id_ftype * this_id
Definition: frame-unwind.h:152
all_commands
Definition: command.h:39
frame_info::next
struct frame_info * next
Definition: frame.c:147
sentinel-frame.h
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
gdbarch_pc_regnum
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:2163
backtrace_past_entry
static int backtrace_past_entry
Definition: frame.c:295
frame_id_build_wild
struct frame_id frame_id_build_wild(CORE_ADDR stack_addr)
Definition: frame.c:636
FID_STACK_SENTINEL
Definition: frame.h:94
TAILCALL_FRAME
Definition: frame.h:252
value_contents_raw
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1158
symtab_and_line::line
int line
Definition: symtab.h:1757
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
get_frame_memory_signed
LONGEST get_frame_memory_signed(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2661
minimal_symbol
Definition: symtab.h:623
annotate_frames_invalid
void annotate_frames_invalid(void)
Definition: annotate.c:205
frame_base::unwind
const struct frame_unwind * unwind
Definition: frame-base.h:62
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
class_maintenance
Definition: command.h:43
get_pc_function_start
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
Definition: blockframe.c:86
frame_debug
unsigned int frame_debug
Definition: frame.c:274
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
annotate.h
language_unknown
Definition: defs.h:205
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
gdbarch_unwind_pc_p
int gdbarch_unwind_pc_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3062
frame_info::stop_string
const char * stop_string
Definition: frame.c:157
compute_frame_id
static void compute_frame_id(struct frame_info *fi)
Definition: frame.c:492
get_prev_frame_if_no_cycle
static struct frame_info * get_prev_frame_if_no_cycle(struct frame_info *this_frame)
Definition: frame.c:1890
skip_unwritable_frames
struct frame_info * skip_unwritable_frames(struct frame_info *frame)
Definition: frame.c:459
valprint.h
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
symbol_symtab
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:5803
class_obscure
Definition: command.h:43
CC_NOT_SAVED
Definition: frame.c:69
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
gdbcmd.h
has_stack_frames
int has_stack_frames(void)
Definition: frame.c:1609
get_frame_program_space
struct program_space * get_frame_program_space(struct frame_info *frame)
Definition: frame.c:2629
frame_base::this_base
frame_this_base_ftype * this_base
Definition: frame-base.h:63
REG_UNAVAILABLE
Definition: common-regcache.h:40
get_frame_func
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:1001
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
frame_id
Definition: frame.h:111
val_print_not_saved
void val_print_not_saved(struct ui_file *stream)
Definition: valprint.c:362
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
LONGEST
long long LONGEST
Definition: common-types.h:52
is_executing
int is_executing(ptid_t ptid)
Definition: thread.c:981
regcache_cooked_write
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:873
frame_unwinder_is
int frame_unwinder_is(struct frame_info *fi, const struct frame_unwind *unwinder)
Definition: frame.c:2599
program_space
Definition: progspace.h:137
get_frame_memory
void get_frame_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
Definition: frame.c:2654
gdbarch_code_of_frame_writable
int gdbarch_code_of_frame_writable(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:2429
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
frame_base_find_by_frame
const struct frame_base * frame_base_find_by_frame(struct frame_info *this_frame)
Definition: frame-base.c:105
do_frame_register_read
static enum register_status do_frame_register_read(void *src, int regnum, gdb_byte *buf)
Definition: frame.c:1012