1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Local non-gdb includes. */
26 #include "dummy-frame.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
30 #include "gdb_obstack.h"
33 #include "gdbthread.h"
36 #include "inline-frame.h"
39 #include "observable.h"
41 #include "sentinel-frame.h"
43 #include "tracepoint.h"
44 #include "user-regs.h"
48 /* The sentinel frame terminates the innermost end of the frame chain.
49 If unwound, it returns the information needed to construct an
52 The current frame, which is the innermost frame, can be found at
53 sentinel_frame->prev. */
55 static struct frame_info
*sentinel_frame
;
57 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
58 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
60 /* Status of some values cached in the frame_info object. */
62 enum cached_copy_status
64 /* Value is unknown. */
67 /* We have a value. */
70 /* Value was not saved. */
73 /* Value is unavailable. */
77 /* We keep a cache of stack frames, each of which is a "struct
78 frame_info". The innermost one gets allocated (in
79 wait_for_inferior) each time the inferior stops; sentinel_frame
80 points to it. Additional frames get allocated (in get_prev_frame)
81 as needed, and are chained through the next and prev fields. Any
82 time that the frame cache becomes invalid (most notably when we
83 execute something, but also if we change how we interpret the
84 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
85 which reads new symbols)), we should call reinit_frame_cache. */
89 /* Level of this frame. The inner-most (youngest) frame is at level
90 0. As you move towards the outer-most (oldest) frame, the level
91 increases. This is a cached value. It could just as easily be
92 computed by counting back from the selected frame to the inner
94 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
95 reserved to indicate a bogus frame - one that has been created
96 just to keep GDB happy (GDB always needs a frame). For the
97 moment leave this as speculation. */
100 /* The frame's program space. */
101 struct program_space
*pspace
;
103 /* The frame's address space. */
104 const address_space
*aspace
;
106 /* The frame's low-level unwinder and corresponding cache. The
107 low-level unwinder is responsible for unwinding register values
108 for the previous frame. The low-level unwind methods are
109 selected based on the presence, or otherwise, of register unwind
110 information such as CFI. */
111 void *prologue_cache
;
112 const struct frame_unwind
*unwind
;
114 /* Cached copy of the previous frame's architecture. */
118 struct gdbarch
*arch
;
121 /* Cached copy of the previous frame's resume address. */
123 enum cached_copy_status status
;
127 /* Cached copy of the previous frame's function address. */
134 /* This frame's ID. */
138 struct frame_id value
;
141 /* The frame's high-level base methods, and corresponding cache.
142 The high level base methods are selected based on the frame's
144 const struct frame_base
*base
;
147 /* Pointers to the next (down, inner, younger) and previous (up,
148 outer, older) frame_info's in the frame cache. */
149 struct frame_info
*next
; /* down, inner, younger */
151 struct frame_info
*prev
; /* up, outer, older */
153 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
154 could. Only valid when PREV_P is set. */
155 enum unwind_stop_reason stop_reason
;
157 /* A frame specific string describing the STOP_REASON in more detail.
158 Only valid when PREV_P is set, but even then may still be NULL. */
159 const char *stop_string
;
162 /* A frame stash used to speed up frame lookups. Create a hash table
163 to stash frames previously accessed from the frame cache for
164 quicker subsequent retrieval. The hash table is emptied whenever
165 the frame cache is invalidated. */
167 static htab_t frame_stash
;
169 /* Internal function to calculate a hash from the frame_id addresses,
170 using as many valid addresses as possible. Frames below level 0
171 are not stored in the hash table. */
174 frame_addr_hash (const void *ap
)
176 const struct frame_info
*frame
= (const struct frame_info
*) ap
;
177 const struct frame_id f_id
= frame
->this_id
.value
;
180 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
182 || f_id
.special_addr_p
);
184 if (f_id
.stack_status
== FID_STACK_VALID
)
185 hash
= iterative_hash (&f_id
.stack_addr
,
186 sizeof (f_id
.stack_addr
), hash
);
187 if (f_id
.code_addr_p
)
188 hash
= iterative_hash (&f_id
.code_addr
,
189 sizeof (f_id
.code_addr
), hash
);
190 if (f_id
.special_addr_p
)
191 hash
= iterative_hash (&f_id
.special_addr
,
192 sizeof (f_id
.special_addr
), hash
);
197 /* Internal equality function for the hash table. This function
198 defers equality operations to frame_id_eq. */
201 frame_addr_hash_eq (const void *a
, const void *b
)
203 const struct frame_info
*f_entry
= (const struct frame_info
*) a
;
204 const struct frame_info
*f_element
= (const struct frame_info
*) b
;
206 return frame_id_eq (f_entry
->this_id
.value
,
207 f_element
->this_id
.value
);
210 /* Internal function to create the frame_stash hash table. 100 seems
211 to be a good compromise to start the hash table at. */
214 frame_stash_create (void)
216 frame_stash
= htab_create (100,
222 /* Internal function to add a frame to the frame_stash hash table.
223 Returns false if a frame with the same ID was already stashed, true
227 frame_stash_add (struct frame_info
*frame
)
229 struct frame_info
**slot
;
231 /* Do not try to stash the sentinel frame. */
232 gdb_assert (frame
->level
>= 0);
234 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
238 /* If we already have a frame in the stack with the same id, we
239 either have a stack cycle (corrupted stack?), or some bug
240 elsewhere in GDB. In any case, ignore the duplicate and return
241 an indication to the caller. */
249 /* Internal function to search the frame stash for an entry with the
250 given frame ID. If found, return that frame. Otherwise return
253 static struct frame_info
*
254 frame_stash_find (struct frame_id id
)
256 struct frame_info dummy
;
257 struct frame_info
*frame
;
259 dummy
.this_id
.value
= id
;
260 frame
= (struct frame_info
*) htab_find (frame_stash
, &dummy
);
264 /* Internal function to invalidate the frame stash by removing all
265 entries in it. This only occurs when the frame cache is
269 frame_stash_invalidate (void)
271 htab_empty (frame_stash
);
275 scoped_restore_selected_frame::scoped_restore_selected_frame ()
277 m_fid
= get_frame_id (get_selected_frame (NULL
));
281 scoped_restore_selected_frame::~scoped_restore_selected_frame ()
283 frame_info
*frame
= frame_find_by_id (m_fid
);
285 warning (_("Unable to restore previously selected frame."));
287 select_frame (frame
);
290 /* Flag to control debugging. */
292 unsigned int frame_debug
;
294 show_frame_debug (struct ui_file
*file
, int from_tty
,
295 struct cmd_list_element
*c
, const char *value
)
297 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
300 /* Flag to indicate whether backtraces should stop at main et.al. */
302 static int backtrace_past_main
;
304 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
305 struct cmd_list_element
*c
, const char *value
)
307 fprintf_filtered (file
,
308 _("Whether backtraces should "
309 "continue past \"main\" is %s.\n"),
313 static int backtrace_past_entry
;
315 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
316 struct cmd_list_element
*c
, const char *value
)
318 fprintf_filtered (file
, _("Whether backtraces should continue past the "
319 "entry point of a program is %s.\n"),
323 static unsigned int backtrace_limit
= UINT_MAX
;
325 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
326 struct cmd_list_element
*c
, const char *value
)
328 fprintf_filtered (file
,
329 _("An upper bound on the number "
330 "of backtrace levels is %s.\n"),
336 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
339 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
341 fprintf_unfiltered (file
, "!%s", name
);
345 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
347 fprintf_unfiltered (file
, "{");
349 if (id
.stack_status
== FID_STACK_INVALID
)
350 fprintf_unfiltered (file
, "!stack");
351 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
352 fprintf_unfiltered (file
, "stack=<unavailable>");
353 else if (id
.stack_status
== FID_STACK_SENTINEL
)
354 fprintf_unfiltered (file
, "stack=<sentinel>");
356 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
357 fprintf_unfiltered (file
, ",");
359 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
360 fprintf_unfiltered (file
, ",");
362 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
364 if (id
.artificial_depth
)
365 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
367 fprintf_unfiltered (file
, "}");
371 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
376 fprintf_unfiltered (file
, "NORMAL_FRAME");
379 fprintf_unfiltered (file
, "DUMMY_FRAME");
382 fprintf_unfiltered (file
, "INLINE_FRAME");
385 fprintf_unfiltered (file
, "TAILCALL_FRAME");
388 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
391 fprintf_unfiltered (file
, "ARCH_FRAME");
394 fprintf_unfiltered (file
, "SENTINEL_FRAME");
397 fprintf_unfiltered (file
, "<unknown type>");
403 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
407 fprintf_unfiltered (file
, "<NULL frame>");
410 fprintf_unfiltered (file
, "{");
411 fprintf_unfiltered (file
, "level=%d", fi
->level
);
412 fprintf_unfiltered (file
, ",");
413 fprintf_unfiltered (file
, "type=");
414 if (fi
->unwind
!= NULL
)
415 fprint_frame_type (file
, fi
->unwind
->type
);
417 fprintf_unfiltered (file
, "<unknown>");
418 fprintf_unfiltered (file
, ",");
419 fprintf_unfiltered (file
, "unwind=");
420 if (fi
->unwind
!= NULL
)
421 gdb_print_host_address (fi
->unwind
, file
);
423 fprintf_unfiltered (file
, "<unknown>");
424 fprintf_unfiltered (file
, ",");
425 fprintf_unfiltered (file
, "pc=");
426 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
427 fprintf_unfiltered (file
, "<unknown>");
428 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
429 fprintf_unfiltered (file
, "%s",
430 hex_string (fi
->next
->prev_pc
.value
));
431 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
432 val_print_not_saved (file
);
433 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
434 val_print_unavailable (file
);
435 fprintf_unfiltered (file
, ",");
436 fprintf_unfiltered (file
, "id=");
438 fprint_frame_id (file
, fi
->this_id
.value
);
440 fprintf_unfiltered (file
, "<unknown>");
441 fprintf_unfiltered (file
, ",");
442 fprintf_unfiltered (file
, "func=");
443 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
444 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
446 fprintf_unfiltered (file
, "<unknown>");
447 fprintf_unfiltered (file
, "}");
450 /* Given FRAME, return the enclosing frame as found in real frames read-in from
451 inferior memory. Skip any previous frames which were made up by GDB.
452 Return FRAME if FRAME is a non-artificial frame.
453 Return NULL if FRAME is the start of an artificial-only chain. */
455 static struct frame_info
*
456 skip_artificial_frames (struct frame_info
*frame
)
458 /* Note we use get_prev_frame_always, and not get_prev_frame. The
459 latter will truncate the frame chain, leading to this function
460 unintentionally returning a null_frame_id (e.g., when the user
461 sets a backtrace limit).
463 Note that for record targets we may get a frame chain that consists
464 of artificial frames only. */
465 while (get_frame_type (frame
) == INLINE_FRAME
466 || get_frame_type (frame
) == TAILCALL_FRAME
)
468 frame
= get_prev_frame_always (frame
);
477 skip_unwritable_frames (struct frame_info
*frame
)
479 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
481 frame
= get_prev_frame (frame
);
492 skip_tailcall_frames (struct frame_info
*frame
)
494 while (get_frame_type (frame
) == TAILCALL_FRAME
)
496 /* Note that for record targets we may get a frame chain that consists of
497 tailcall frames only. */
498 frame
= get_prev_frame (frame
);
506 /* Compute the frame's uniq ID that can be used to, later, re-find the
510 compute_frame_id (struct frame_info
*fi
)
512 gdb_assert (!fi
->this_id
.p
);
515 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
517 /* Find the unwinder. */
518 if (fi
->unwind
== NULL
)
519 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
520 /* Find THIS frame's ID. */
521 /* Default to outermost if no ID is found. */
522 fi
->this_id
.value
= outer_frame_id
;
523 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
524 gdb_assert (frame_id_p (fi
->this_id
.value
));
528 fprintf_unfiltered (gdb_stdlog
, "-> ");
529 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
530 fprintf_unfiltered (gdb_stdlog
, " }\n");
534 /* Return a frame uniq ID that can be used to, later, re-find the
538 get_frame_id (struct frame_info
*fi
)
541 return null_frame_id
;
547 /* If we haven't computed the frame id yet, then it must be that
548 this is the current frame. Compute it now, and stash the
549 result. The IDs of other frames are computed as soon as
550 they're created, in order to detect cycles. See
551 get_prev_frame_if_no_cycle. */
552 gdb_assert (fi
->level
== 0);
555 compute_frame_id (fi
);
557 /* Since this is the first frame in the chain, this should
559 stashed
= frame_stash_add (fi
);
560 gdb_assert (stashed
);
563 return fi
->this_id
.value
;
567 get_stack_frame_id (struct frame_info
*next_frame
)
569 return get_frame_id (skip_artificial_frames (next_frame
));
573 frame_unwind_caller_id (struct frame_info
*next_frame
)
575 struct frame_info
*this_frame
;
577 /* Use get_prev_frame_always, and not get_prev_frame. The latter
578 will truncate the frame chain, leading to this function
579 unintentionally returning a null_frame_id (e.g., when a caller
580 requests the frame ID of "main()"s caller. */
582 next_frame
= skip_artificial_frames (next_frame
);
583 if (next_frame
== NULL
)
584 return null_frame_id
;
586 this_frame
= get_prev_frame_always (next_frame
);
588 return get_frame_id (skip_artificial_frames (this_frame
));
590 return null_frame_id
;
593 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
594 const struct frame_id sentinel_frame_id
= { 0, 0, 0, FID_STACK_SENTINEL
, 0, 1, 0 };
595 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
598 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
599 CORE_ADDR special_addr
)
601 struct frame_id id
= null_frame_id
;
603 id
.stack_addr
= stack_addr
;
604 id
.stack_status
= FID_STACK_VALID
;
605 id
.code_addr
= code_addr
;
607 id
.special_addr
= special_addr
;
608 id
.special_addr_p
= 1;
615 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
617 struct frame_id id
= null_frame_id
;
619 id
.stack_status
= FID_STACK_UNAVAILABLE
;
620 id
.code_addr
= code_addr
;
628 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
629 CORE_ADDR special_addr
)
631 struct frame_id id
= null_frame_id
;
633 id
.stack_status
= FID_STACK_UNAVAILABLE
;
634 id
.code_addr
= code_addr
;
636 id
.special_addr
= special_addr
;
637 id
.special_addr_p
= 1;
642 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
644 struct frame_id id
= null_frame_id
;
646 id
.stack_addr
= stack_addr
;
647 id
.stack_status
= FID_STACK_VALID
;
648 id
.code_addr
= code_addr
;
654 frame_id_build_wild (CORE_ADDR stack_addr
)
656 struct frame_id id
= null_frame_id
;
658 id
.stack_addr
= stack_addr
;
659 id
.stack_status
= FID_STACK_VALID
;
664 frame_id_p (struct frame_id l
)
668 /* The frame is valid iff it has a valid stack address. */
669 p
= l
.stack_status
!= FID_STACK_INVALID
;
670 /* outer_frame_id is also valid. */
671 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
675 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
676 fprint_frame_id (gdb_stdlog
, l
);
677 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
683 frame_id_artificial_p (struct frame_id l
)
688 return (l
.artificial_depth
!= 0);
692 frame_id_eq (struct frame_id l
, struct frame_id r
)
696 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
697 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
698 /* The outermost frame marker is equal to itself. This is the
699 dodgy thing about outer_frame_id, since between execution steps
700 we might step into another function - from which we can't
701 unwind either. More thought required to get rid of
704 else if (l
.stack_status
== FID_STACK_INVALID
705 || r
.stack_status
== FID_STACK_INVALID
)
706 /* Like a NaN, if either ID is invalid, the result is false.
707 Note that a frame ID is invalid iff it is the null frame ID. */
709 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
710 /* If .stack addresses are different, the frames are different. */
712 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
713 /* An invalid code addr is a wild card. If .code addresses are
714 different, the frames are different. */
716 else if (l
.special_addr_p
&& r
.special_addr_p
717 && l
.special_addr
!= r
.special_addr
)
718 /* An invalid special addr is a wild card (or unused). Otherwise
719 if special addresses are different, the frames are different. */
721 else if (l
.artificial_depth
!= r
.artificial_depth
)
722 /* If artifical depths are different, the frames must be different. */
725 /* Frames are equal. */
730 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
731 fprint_frame_id (gdb_stdlog
, l
);
732 fprintf_unfiltered (gdb_stdlog
, ",r=");
733 fprint_frame_id (gdb_stdlog
, r
);
734 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
739 /* Safety net to check whether frame ID L should be inner to
740 frame ID R, according to their stack addresses.
742 This method cannot be used to compare arbitrary frames, as the
743 ranges of valid stack addresses may be discontiguous (e.g. due
746 However, it can be used as safety net to discover invalid frame
747 IDs in certain circumstances. Assuming that NEXT is the immediate
748 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
750 * The stack address of NEXT must be inner-than-or-equal to the stack
753 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
756 * If NEXT and THIS have different stack addresses, no other frame
757 in the frame chain may have a stack address in between.
759 Therefore, if frame_id_inner (TEST, THIS) holds, but
760 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
761 to a valid frame in the frame chain.
763 The sanity checks above cannot be performed when a SIGTRAMP frame
764 is involved, because signal handlers might be executed on a different
765 stack than the stack used by the routine that caused the signal
766 to be raised. This can happen for instance when a thread exceeds
767 its maximum stack size. In this case, certain compilers implement
768 a stack overflow strategy that cause the handler to be run on a
772 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
776 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
777 /* Like NaN, any operation involving an invalid ID always fails.
778 Likewise if either ID has an unavailable stack address. */
780 else if (l
.artificial_depth
> r
.artificial_depth
781 && l
.stack_addr
== r
.stack_addr
782 && l
.code_addr_p
== r
.code_addr_p
783 && l
.special_addr_p
== r
.special_addr_p
784 && l
.special_addr
== r
.special_addr
)
786 /* Same function, different inlined functions. */
787 const struct block
*lb
, *rb
;
789 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
791 lb
= block_for_pc (l
.code_addr
);
792 rb
= block_for_pc (r
.code_addr
);
794 if (lb
== NULL
|| rb
== NULL
)
795 /* Something's gone wrong. */
798 /* This will return true if LB and RB are the same block, or
799 if the block with the smaller depth lexically encloses the
800 block with the greater depth. */
801 inner
= contained_in (lb
, rb
);
804 /* Only return non-zero when strictly inner than. Note that, per
805 comment in "frame.h", there is some fuzz here. Frameless
806 functions are not strictly inner than (same .stack but
807 different .code and/or .special address). */
808 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
811 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
812 fprint_frame_id (gdb_stdlog
, l
);
813 fprintf_unfiltered (gdb_stdlog
, ",r=");
814 fprint_frame_id (gdb_stdlog
, r
);
815 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
821 frame_find_by_id (struct frame_id id
)
823 struct frame_info
*frame
, *prev_frame
;
825 /* ZERO denotes the null frame, let the caller decide what to do
826 about it. Should it instead return get_current_frame()? */
827 if (!frame_id_p (id
))
830 /* Check for the sentinel frame. */
831 if (frame_id_eq (id
, sentinel_frame_id
))
832 return sentinel_frame
;
834 /* Try using the frame stash first. Finding it there removes the need
835 to perform the search by looping over all frames, which can be very
836 CPU-intensive if the number of frames is very high (the loop is O(n)
837 and get_prev_frame performs a series of checks that are relatively
838 expensive). This optimization is particularly useful when this function
839 is called from another function (such as value_fetch_lazy, case
840 VALUE_LVAL (val) == lval_register) which already loops over all frames,
841 making the overall behavior O(n^2). */
842 frame
= frame_stash_find (id
);
846 for (frame
= get_current_frame (); ; frame
= prev_frame
)
848 struct frame_id self
= get_frame_id (frame
);
850 if (frame_id_eq (id
, self
))
851 /* An exact match. */
854 prev_frame
= get_prev_frame (frame
);
858 /* As a safety net to avoid unnecessary backtracing while trying
859 to find an invalid ID, we check for a common situation where
860 we can detect from comparing stack addresses that no other
861 frame in the current frame chain can have this ID. See the
862 comment at frame_id_inner for details. */
863 if (get_frame_type (frame
) == NORMAL_FRAME
864 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
865 && frame_id_inner (get_frame_arch (prev_frame
), id
,
866 get_frame_id (prev_frame
)))
873 frame_unwind_pc (struct frame_info
*this_frame
)
875 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
877 struct gdbarch
*prev_gdbarch
;
881 /* The right way. The `pure' way. The one true way. This
882 method depends solely on the register-unwind code to
883 determine the value of registers in THIS frame, and hence
884 the value of this frame's PC (resume address). A typical
885 implementation is no more than:
887 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
888 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
890 Note: this method is very heavily dependent on a correct
891 register-unwind implementation, it pays to fix that
892 method first; this method is frame type agnostic, since
893 it only deals with register values, it works with any
894 frame. This is all in stark contrast to the old
895 FRAME_SAVED_PC which would try to directly handle all the
896 different ways that a PC could be unwound. */
897 prev_gdbarch
= frame_unwind_arch (this_frame
);
901 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
904 CATCH (ex
, RETURN_MASK_ERROR
)
906 if (ex
.error
== NOT_AVAILABLE_ERROR
)
908 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
911 fprintf_unfiltered (gdb_stdlog
,
912 "{ frame_unwind_pc (this_frame=%d)"
913 " -> <unavailable> }\n",
916 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
918 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
921 fprintf_unfiltered (gdb_stdlog
,
922 "{ frame_unwind_pc (this_frame=%d)"
923 " -> <not saved> }\n",
927 throw_exception (ex
);
933 this_frame
->prev_pc
.value
= pc
;
934 this_frame
->prev_pc
.status
= CC_VALUE
;
936 fprintf_unfiltered (gdb_stdlog
,
937 "{ frame_unwind_pc (this_frame=%d) "
940 hex_string (this_frame
->prev_pc
.value
));
944 if (this_frame
->prev_pc
.status
== CC_VALUE
)
945 return this_frame
->prev_pc
.value
;
946 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
947 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
948 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
949 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
951 internal_error (__FILE__
, __LINE__
,
952 "unexpected prev_pc status: %d",
953 (int) this_frame
->prev_pc
.status
);
957 frame_unwind_caller_pc (struct frame_info
*this_frame
)
959 this_frame
= skip_artificial_frames (this_frame
);
961 /* We must have a non-artificial frame. The caller is supposed to check
962 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
964 gdb_assert (this_frame
!= NULL
);
966 return frame_unwind_pc (this_frame
);
970 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
972 struct frame_info
*next_frame
= this_frame
->next
;
974 if (!next_frame
->prev_func
.p
)
976 CORE_ADDR addr_in_block
;
978 /* Make certain that this, and not the adjacent, function is
980 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
982 next_frame
->prev_func
.p
= -1;
984 fprintf_unfiltered (gdb_stdlog
,
985 "{ get_frame_func (this_frame=%d)"
986 " -> unavailable }\n",
991 next_frame
->prev_func
.p
= 1;
992 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
994 fprintf_unfiltered (gdb_stdlog
,
995 "{ get_frame_func (this_frame=%d) -> %s }\n",
997 hex_string (next_frame
->prev_func
.addr
));
1001 if (next_frame
->prev_func
.p
< 0)
1008 *pc
= next_frame
->prev_func
.addr
;
1014 get_frame_func (struct frame_info
*this_frame
)
1018 if (!get_frame_func_if_available (this_frame
, &pc
))
1019 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1024 std::unique_ptr
<readonly_detached_regcache
>
1025 frame_save_as_regcache (struct frame_info
*this_frame
)
1027 auto cooked_read
= [this_frame
] (int regnum
, gdb_byte
*buf
)
1029 if (!deprecated_frame_register_read (this_frame
, regnum
, buf
))
1030 return REG_UNAVAILABLE
;
1035 std::unique_ptr
<readonly_detached_regcache
> regcache
1036 (new readonly_detached_regcache (get_frame_arch (this_frame
), cooked_read
));
1042 frame_pop (struct frame_info
*this_frame
)
1044 struct frame_info
*prev_frame
;
1046 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1048 /* Popping a dummy frame involves restoring more than just registers.
1049 dummy_frame_pop does all the work. */
1050 dummy_frame_pop (get_frame_id (this_frame
), inferior_thread ());
1054 /* Ensure that we have a frame to pop to. */
1055 prev_frame
= get_prev_frame_always (this_frame
);
1058 error (_("Cannot pop the initial frame."));
1060 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1061 entering THISFRAME. */
1062 prev_frame
= skip_tailcall_frames (prev_frame
);
1064 if (prev_frame
== NULL
)
1065 error (_("Cannot find the caller frame."));
1067 /* Make a copy of all the register values unwound from this frame.
1068 Save them in a scratch buffer so that there isn't a race between
1069 trying to extract the old values from the current regcache while
1070 at the same time writing new values into that same cache. */
1071 std::unique_ptr
<readonly_detached_regcache
> scratch
1072 = frame_save_as_regcache (prev_frame
);
1074 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1075 target's register cache that it is about to be hit with a burst
1076 register transfer and that the sequence of register writes should
1077 be batched. The pair target_prepare_to_store() and
1078 target_store_registers() kind of suggest this functionality.
1079 Unfortunately, they don't implement it. Their lack of a formal
1080 definition can lead to targets writing back bogus values
1081 (arguably a bug in the target code mind). */
1082 /* Now copy those saved registers into the current regcache. */
1083 get_current_regcache ()->restore (scratch
.get ());
1085 /* We've made right mess of GDB's local state, just discard
1087 reinit_frame_cache ();
1091 frame_register_unwind (frame_info
*next_frame
, int regnum
,
1092 int *optimizedp
, int *unavailablep
,
1093 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1094 int *realnump
, gdb_byte
*bufferp
)
1096 struct value
*value
;
1098 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1099 that the value proper does not need to be fetched. */
1100 gdb_assert (optimizedp
!= NULL
);
1101 gdb_assert (lvalp
!= NULL
);
1102 gdb_assert (addrp
!= NULL
);
1103 gdb_assert (realnump
!= NULL
);
1104 /* gdb_assert (bufferp != NULL); */
1106 value
= frame_unwind_register_value (next_frame
, regnum
);
1108 gdb_assert (value
!= NULL
);
1110 *optimizedp
= value_optimized_out (value
);
1111 *unavailablep
= !value_entirely_available (value
);
1112 *lvalp
= VALUE_LVAL (value
);
1113 *addrp
= value_address (value
);
1114 if (*lvalp
== lval_register
)
1115 *realnump
= VALUE_REGNUM (value
);
1121 if (!*optimizedp
&& !*unavailablep
)
1122 memcpy (bufferp
, value_contents_all (value
),
1123 TYPE_LENGTH (value_type (value
)));
1125 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1128 /* Dispose of the new value. This prevents watchpoints from
1129 trying to watch the saved frame pointer. */
1130 release_value (value
);
1134 frame_register (struct frame_info
*frame
, int regnum
,
1135 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1136 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1138 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1139 that the value proper does not need to be fetched. */
1140 gdb_assert (optimizedp
!= NULL
);
1141 gdb_assert (lvalp
!= NULL
);
1142 gdb_assert (addrp
!= NULL
);
1143 gdb_assert (realnump
!= NULL
);
1144 /* gdb_assert (bufferp != NULL); */
1146 /* Obtain the register value by unwinding the register from the next
1147 (more inner frame). */
1148 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1149 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1150 lvalp
, addrp
, realnump
, bufferp
);
1154 frame_unwind_register (frame_info
*next_frame
, int regnum
, gdb_byte
*buf
)
1160 enum lval_type lval
;
1162 frame_register_unwind (next_frame
, regnum
, &optimized
, &unavailable
,
1163 &lval
, &addr
, &realnum
, buf
);
1166 throw_error (OPTIMIZED_OUT_ERROR
,
1167 _("Register %d was not saved"), regnum
);
1169 throw_error (NOT_AVAILABLE_ERROR
,
1170 _("Register %d is not available"), regnum
);
1174 get_frame_register (struct frame_info
*frame
,
1175 int regnum
, gdb_byte
*buf
)
1177 frame_unwind_register (frame
->next
, regnum
, buf
);
1181 frame_unwind_register_value (frame_info
*next_frame
, int regnum
)
1183 struct gdbarch
*gdbarch
;
1184 struct value
*value
;
1186 gdb_assert (next_frame
!= NULL
);
1187 gdbarch
= frame_unwind_arch (next_frame
);
1191 fprintf_unfiltered (gdb_stdlog
,
1192 "{ frame_unwind_register_value "
1193 "(frame=%d,regnum=%d(%s),...) ",
1194 next_frame
->level
, regnum
,
1195 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1198 /* Find the unwinder. */
1199 if (next_frame
->unwind
== NULL
)
1200 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
1202 /* Ask this frame to unwind its register. */
1203 value
= next_frame
->unwind
->prev_register (next_frame
,
1204 &next_frame
->prologue_cache
,
1209 fprintf_unfiltered (gdb_stdlog
, "->");
1210 if (value_optimized_out (value
))
1212 fprintf_unfiltered (gdb_stdlog
, " ");
1213 val_print_optimized_out (value
, gdb_stdlog
);
1217 if (VALUE_LVAL (value
) == lval_register
)
1218 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1219 VALUE_REGNUM (value
));
1220 else if (VALUE_LVAL (value
) == lval_memory
)
1221 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1223 value_address (value
)));
1225 fprintf_unfiltered (gdb_stdlog
, " computed");
1227 if (value_lazy (value
))
1228 fprintf_unfiltered (gdb_stdlog
, " lazy");
1232 const gdb_byte
*buf
= value_contents (value
);
1234 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1235 fprintf_unfiltered (gdb_stdlog
, "[");
1236 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1237 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1238 fprintf_unfiltered (gdb_stdlog
, "]");
1242 fprintf_unfiltered (gdb_stdlog
, " }\n");
1249 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1251 return frame_unwind_register_value (frame
->next
, regnum
);
1255 frame_unwind_register_signed (frame_info
*next_frame
, int regnum
)
1257 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1258 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1259 int size
= register_size (gdbarch
, regnum
);
1260 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1262 gdb_assert (value
!= NULL
);
1264 if (value_optimized_out (value
))
1266 throw_error (OPTIMIZED_OUT_ERROR
,
1267 _("Register %d was not saved"), regnum
);
1269 if (!value_entirely_available (value
))
1271 throw_error (NOT_AVAILABLE_ERROR
,
1272 _("Register %d is not available"), regnum
);
1275 LONGEST r
= extract_signed_integer (value_contents_all (value
), size
,
1278 release_value (value
);
1283 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1285 return frame_unwind_register_signed (frame
->next
, regnum
);
1289 frame_unwind_register_unsigned (frame_info
*next_frame
, int regnum
)
1291 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1292 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1293 int size
= register_size (gdbarch
, regnum
);
1294 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1296 gdb_assert (value
!= NULL
);
1298 if (value_optimized_out (value
))
1300 throw_error (OPTIMIZED_OUT_ERROR
,
1301 _("Register %d was not saved"), regnum
);
1303 if (!value_entirely_available (value
))
1305 throw_error (NOT_AVAILABLE_ERROR
,
1306 _("Register %d is not available"), regnum
);
1309 ULONGEST r
= extract_unsigned_integer (value_contents_all (value
), size
,
1312 release_value (value
);
1317 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1319 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1323 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1326 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1328 if (!value_optimized_out (regval
)
1329 && value_entirely_available (regval
))
1331 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1332 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1333 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1335 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1343 put_frame_register (struct frame_info
*frame
, int regnum
,
1344 const gdb_byte
*buf
)
1346 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1350 enum lval_type lval
;
1353 frame_register (frame
, regnum
, &optim
, &unavail
,
1354 &lval
, &addr
, &realnum
, NULL
);
1356 error (_("Attempt to assign to a register that was not saved."));
1361 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1365 get_current_regcache ()->cooked_write (realnum
, buf
);
1368 error (_("Attempt to assign to an unmodifiable value."));
1372 /* This function is deprecated. Use get_frame_register_value instead,
1373 which provides more accurate information.
1375 Find and return the value of REGNUM for the specified stack frame.
1376 The number of bytes copied is REGISTER_SIZE (REGNUM).
1378 Returns 0 if the register value could not be found. */
1381 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1386 enum lval_type lval
;
1390 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1391 &lval
, &addr
, &realnum
, myaddr
);
1393 return !optimized
&& !unavailable
;
1397 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1398 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1399 int *optimizedp
, int *unavailablep
)
1401 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1406 /* Skip registers wholly inside of OFFSET. */
1407 while (offset
>= register_size (gdbarch
, regnum
))
1409 offset
-= register_size (gdbarch
, regnum
);
1413 /* Ensure that we will not read beyond the end of the register file.
1414 This can only ever happen if the debug information is bad. */
1416 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1417 for (i
= regnum
; i
< numregs
; i
++)
1419 int thissize
= register_size (gdbarch
, i
);
1422 break; /* This register is not available on this architecture. */
1423 maxsize
+= thissize
;
1426 error (_("Bad debug information detected: "
1427 "Attempt to read %d bytes from registers."), len
);
1429 /* Copy the data. */
1432 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1437 if (curr_len
== register_size (gdbarch
, regnum
))
1439 enum lval_type lval
;
1443 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1444 &lval
, &addr
, &realnum
, myaddr
);
1445 if (*optimizedp
|| *unavailablep
)
1450 struct value
*value
= frame_unwind_register_value (frame
->next
,
1452 gdb_assert (value
!= NULL
);
1453 *optimizedp
= value_optimized_out (value
);
1454 *unavailablep
= !value_entirely_available (value
);
1456 if (*optimizedp
|| *unavailablep
)
1458 release_value (value
);
1461 memcpy (myaddr
, value_contents_all (value
) + offset
, curr_len
);
1462 release_value (value
);
1477 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1478 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1480 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1482 /* Skip registers wholly inside of OFFSET. */
1483 while (offset
>= register_size (gdbarch
, regnum
))
1485 offset
-= register_size (gdbarch
, regnum
);
1489 /* Copy the data. */
1492 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1497 if (curr_len
== register_size (gdbarch
, regnum
))
1499 put_frame_register (frame
, regnum
, myaddr
);
1503 struct value
*value
= frame_unwind_register_value (frame
->next
,
1505 gdb_assert (value
!= NULL
);
1507 memcpy ((char *) value_contents_writeable (value
) + offset
, myaddr
,
1509 put_frame_register (frame
, regnum
, value_contents_raw (value
));
1510 release_value (value
);
1520 /* Create a sentinel frame. */
1522 static struct frame_info
*
1523 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1525 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1528 frame
->pspace
= pspace
;
1529 frame
->aspace
= regcache
->aspace ();
1530 /* Explicitly initialize the sentinel frame's cache. Provide it
1531 with the underlying regcache. In the future additional
1532 information, such as the frame's thread will be added. */
1533 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1534 /* For the moment there is only one sentinel frame implementation. */
1535 frame
->unwind
= &sentinel_frame_unwind
;
1536 /* Link this frame back to itself. The frame is self referential
1537 (the unwound PC is the same as the pc), so make it so. */
1538 frame
->next
= frame
;
1539 /* The sentinel frame has a special ID. */
1540 frame
->this_id
.p
= 1;
1541 frame
->this_id
.value
= sentinel_frame_id
;
1544 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1545 fprint_frame (gdb_stdlog
, frame
);
1546 fprintf_unfiltered (gdb_stdlog
, " }\n");
1551 /* Cache for frame addresses already read by gdb. Valid only while
1552 inferior is stopped. Control variables for the frame cache should
1553 be local to this module. */
1555 static struct obstack frame_cache_obstack
;
1558 frame_obstack_zalloc (unsigned long size
)
1560 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1562 memset (data
, 0, size
);
1566 static struct frame_info
*get_prev_frame_always_1 (struct frame_info
*this_frame
);
1569 get_current_frame (void)
1571 struct frame_info
*current_frame
;
1573 /* First check, and report, the lack of registers. Having GDB
1574 report "No stack!" or "No memory" when the target doesn't even
1575 have registers is very confusing. Besides, "printcmd.exp"
1576 explicitly checks that ``print $pc'' with no registers prints "No
1578 if (!target_has_registers
)
1579 error (_("No registers."));
1580 if (!target_has_stack
)
1581 error (_("No stack."));
1582 if (!target_has_memory
)
1583 error (_("No memory."));
1584 /* Traceframes are effectively a substitute for the live inferior. */
1585 if (get_traceframe_number () < 0)
1586 validate_registers_access ();
1588 if (sentinel_frame
== NULL
)
1590 create_sentinel_frame (current_program_space
, get_current_regcache ());
1592 /* Set the current frame before computing the frame id, to avoid
1593 recursion inside compute_frame_id, in case the frame's
1594 unwinder decides to do a symbol lookup (which depends on the
1595 selected frame's block).
1597 This call must always succeed. In particular, nothing inside
1598 get_prev_frame_always_1 should try to unwind from the
1599 sentinel frame, because that could fail/throw, and we always
1600 want to leave with the current frame created and linked in --
1601 we should never end up with the sentinel frame as outermost
1603 current_frame
= get_prev_frame_always_1 (sentinel_frame
);
1604 gdb_assert (current_frame
!= NULL
);
1606 return current_frame
;
1609 /* The "selected" stack frame is used by default for local and arg
1610 access. May be zero, for no selected frame. */
1612 static struct frame_info
*selected_frame
;
1615 has_stack_frames (void)
1617 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1620 /* Traceframes are effectively a substitute for the live inferior. */
1621 if (get_traceframe_number () < 0)
1623 /* No current inferior, no frame. */
1624 if (inferior_ptid
== null_ptid
)
1627 thread_info
*tp
= inferior_thread ();
1628 /* Don't try to read from a dead thread. */
1629 if (tp
->state
== THREAD_EXITED
)
1632 /* ... or from a spinning thread. */
1640 /* Return the selected frame. Always non-NULL (unless there isn't an
1641 inferior sufficient for creating a frame) in which case an error is
1645 get_selected_frame (const char *message
)
1647 if (selected_frame
== NULL
)
1649 if (message
!= NULL
&& !has_stack_frames ())
1650 error (("%s"), message
);
1651 /* Hey! Don't trust this. It should really be re-finding the
1652 last selected frame of the currently selected thread. This,
1653 though, is better than nothing. */
1654 select_frame (get_current_frame ());
1656 /* There is always a frame. */
1657 gdb_assert (selected_frame
!= NULL
);
1658 return selected_frame
;
1661 /* If there is a selected frame, return it. Otherwise, return NULL. */
1664 get_selected_frame_if_set (void)
1666 return selected_frame
;
1669 /* This is a variant of get_selected_frame() which can be called when
1670 the inferior does not have a frame; in that case it will return
1671 NULL instead of calling error(). */
1674 deprecated_safe_get_selected_frame (void)
1676 if (!has_stack_frames ())
1678 return get_selected_frame (NULL
);
1681 /* Select frame FI (or NULL - to invalidate the current frame). */
1684 select_frame (struct frame_info
*fi
)
1686 selected_frame
= fi
;
1687 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1688 frame is being invalidated. */
1690 /* FIXME: kseitz/2002-08-28: It would be nice to call
1691 selected_frame_level_changed_event() right here, but due to limitations
1692 in the current interfaces, we would end up flooding UIs with events
1693 because select_frame() is used extensively internally.
1695 Once we have frame-parameterized frame (and frame-related) commands,
1696 the event notification can be moved here, since this function will only
1697 be called when the user's selected frame is being changed. */
1699 /* Ensure that symbols for this frame are read in. Also, determine the
1700 source language of this frame, and switch to it if desired. */
1705 /* We retrieve the frame's symtab by using the frame PC.
1706 However we cannot use the frame PC as-is, because it usually
1707 points to the instruction following the "call", which is
1708 sometimes the first instruction of another function. So we
1709 rely on get_frame_address_in_block() which provides us with a
1710 PC which is guaranteed to be inside the frame's code
1712 if (get_frame_address_in_block_if_available (fi
, &pc
))
1714 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1717 && compunit_language (cust
) != current_language
->la_language
1718 && compunit_language (cust
) != language_unknown
1719 && language_mode
== language_mode_auto
)
1720 set_language (compunit_language (cust
));
1725 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1726 Always returns a non-NULL value. */
1729 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1731 struct frame_info
*fi
;
1735 fprintf_unfiltered (gdb_stdlog
,
1736 "{ create_new_frame (addr=%s, pc=%s) ",
1737 hex_string (addr
), hex_string (pc
));
1740 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1742 fi
->next
= create_sentinel_frame (current_program_space
,
1743 get_current_regcache ());
1745 /* Set/update this frame's cached PC value, found in the next frame.
1746 Do this before looking for this frame's unwinder. A sniffer is
1747 very likely to read this, and the corresponding unwinder is
1748 entitled to rely that the PC doesn't magically change. */
1749 fi
->next
->prev_pc
.value
= pc
;
1750 fi
->next
->prev_pc
.status
= CC_VALUE
;
1752 /* We currently assume that frame chain's can't cross spaces. */
1753 fi
->pspace
= fi
->next
->pspace
;
1754 fi
->aspace
= fi
->next
->aspace
;
1756 /* Select/initialize both the unwind function and the frame's type
1758 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1761 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1765 fprintf_unfiltered (gdb_stdlog
, "-> ");
1766 fprint_frame (gdb_stdlog
, fi
);
1767 fprintf_unfiltered (gdb_stdlog
, " }\n");
1773 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1774 innermost frame). Be careful to not fall off the bottom of the
1775 frame chain and onto the sentinel frame. */
1778 get_next_frame (struct frame_info
*this_frame
)
1780 if (this_frame
->level
> 0)
1781 return this_frame
->next
;
1786 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
1787 innermost (i.e. current) frame, return the sentinel frame. Thus,
1788 unlike get_next_frame(), NULL will never be returned. */
1791 get_next_frame_sentinel_okay (struct frame_info
*this_frame
)
1793 gdb_assert (this_frame
!= NULL
);
1795 /* Note that, due to the manner in which the sentinel frame is
1796 constructed, this_frame->next still works even when this_frame
1797 is the sentinel frame. But we disallow it here anyway because
1798 calling get_next_frame_sentinel_okay() on the sentinel frame
1799 is likely a coding error. */
1800 gdb_assert (this_frame
!= sentinel_frame
);
1802 return this_frame
->next
;
1805 /* Observer for the target_changed event. */
1808 frame_observer_target_changed (struct target_ops
*target
)
1810 reinit_frame_cache ();
1813 /* Flush the entire frame cache. */
1816 reinit_frame_cache (void)
1818 struct frame_info
*fi
;
1820 /* Tear down all frame caches. */
1821 for (fi
= sentinel_frame
; fi
!= NULL
; fi
= fi
->prev
)
1823 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1824 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1825 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1826 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1829 /* Since we can't really be sure what the first object allocated was. */
1830 obstack_free (&frame_cache_obstack
, 0);
1831 obstack_init (&frame_cache_obstack
);
1833 if (sentinel_frame
!= NULL
)
1834 annotate_frames_invalid ();
1836 sentinel_frame
= NULL
; /* Invalidate cache */
1837 select_frame (NULL
);
1838 frame_stash_invalidate ();
1840 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1843 /* Find where a register is saved (in memory or another register).
1844 The result of frame_register_unwind is just where it is saved
1845 relative to this particular frame. */
1848 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1849 int *optimizedp
, enum lval_type
*lvalp
,
1850 CORE_ADDR
*addrp
, int *realnump
)
1852 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1854 while (this_frame
!= NULL
)
1858 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1859 lvalp
, addrp
, realnump
, NULL
);
1864 if (*lvalp
!= lval_register
)
1868 this_frame
= get_next_frame (this_frame
);
1872 /* Get the previous raw frame, and check that it is not identical to
1873 same other frame frame already in the chain. If it is, there is
1874 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1875 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1876 validity tests, that compare THIS_FRAME and the next frame, we do
1877 this right after creating the previous frame, to avoid ever ending
1878 up with two frames with the same id in the frame chain. */
1880 static struct frame_info
*
1881 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1883 struct frame_info
*prev_frame
;
1885 prev_frame
= get_prev_frame_raw (this_frame
);
1887 /* Don't compute the frame id of the current frame yet. Unwinding
1888 the sentinel frame can fail (e.g., if the thread is gone and we
1889 can't thus read its registers). If we let the cycle detection
1890 code below try to compute a frame ID, then an error thrown from
1891 within the frame ID computation would result in the sentinel
1892 frame as outermost frame, which is bogus. Instead, we'll compute
1893 the current frame's ID lazily in get_frame_id. Note that there's
1894 no point in doing cycle detection when there's only one frame, so
1895 nothing is lost here. */
1896 if (prev_frame
->level
== 0)
1901 compute_frame_id (prev_frame
);
1902 if (!frame_stash_add (prev_frame
))
1904 /* Another frame with the same id was already in the stash. We just
1905 detected a cycle. */
1908 fprintf_unfiltered (gdb_stdlog
, "-> ");
1909 fprint_frame (gdb_stdlog
, NULL
);
1910 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1912 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1914 prev_frame
->next
= NULL
;
1915 this_frame
->prev
= NULL
;
1919 CATCH (ex
, RETURN_MASK_ALL
)
1921 prev_frame
->next
= NULL
;
1922 this_frame
->prev
= NULL
;
1924 throw_exception (ex
);
1931 /* Helper function for get_prev_frame_always, this is called inside a
1932 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1933 there is no such frame. This may throw an exception. */
1935 static struct frame_info
*
1936 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1938 struct gdbarch
*gdbarch
;
1940 gdb_assert (this_frame
!= NULL
);
1941 gdbarch
= get_frame_arch (this_frame
);
1945 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1946 if (this_frame
!= NULL
)
1947 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1949 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1950 fprintf_unfiltered (gdb_stdlog
, ") ");
1953 /* Only try to do the unwind once. */
1954 if (this_frame
->prev_p
)
1958 fprintf_unfiltered (gdb_stdlog
, "-> ");
1959 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1960 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1962 return this_frame
->prev
;
1965 /* If the frame unwinder hasn't been selected yet, we must do so
1966 before setting prev_p; otherwise the check for misbehaved
1967 sniffers will think that this frame's sniffer tried to unwind
1968 further (see frame_cleanup_after_sniffer). */
1969 if (this_frame
->unwind
== NULL
)
1970 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1972 this_frame
->prev_p
= 1;
1973 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1975 /* If we are unwinding from an inline frame, all of the below tests
1976 were already performed when we unwound from the next non-inline
1977 frame. We must skip them, since we can not get THIS_FRAME's ID
1978 until we have unwound all the way down to the previous non-inline
1980 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1981 return get_prev_frame_if_no_cycle (this_frame
);
1983 /* Check that this frame is unwindable. If it isn't, don't try to
1984 unwind to the prev frame. */
1985 this_frame
->stop_reason
1986 = this_frame
->unwind
->stop_reason (this_frame
,
1987 &this_frame
->prologue_cache
);
1989 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1993 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1995 fprintf_unfiltered (gdb_stdlog
, "-> ");
1996 fprint_frame (gdb_stdlog
, NULL
);
1997 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
1998 frame_stop_reason_symbol_string (reason
));
2003 /* Check that this frame's ID isn't inner to (younger, below, next)
2004 the next frame. This happens when a frame unwind goes backwards.
2005 This check is valid only if this frame and the next frame are NORMAL.
2006 See the comment at frame_id_inner for details. */
2007 if (get_frame_type (this_frame
) == NORMAL_FRAME
2008 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2009 && frame_id_inner (get_frame_arch (this_frame
->next
),
2010 get_frame_id (this_frame
),
2011 get_frame_id (this_frame
->next
)))
2013 CORE_ADDR this_pc_in_block
;
2014 struct minimal_symbol
*morestack_msym
;
2015 const char *morestack_name
= NULL
;
2017 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2018 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2019 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2021 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
2022 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2026 fprintf_unfiltered (gdb_stdlog
, "-> ");
2027 fprint_frame (gdb_stdlog
, NULL
);
2028 fprintf_unfiltered (gdb_stdlog
,
2029 " // this frame ID is inner }\n");
2031 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2036 /* Check that this and the next frame do not unwind the PC register
2037 to the same memory location. If they do, then even though they
2038 have different frame IDs, the new frame will be bogus; two
2039 functions can't share a register save slot for the PC. This can
2040 happen when the prologue analyzer finds a stack adjustment, but
2043 This check does assume that the "PC register" is roughly a
2044 traditional PC, even if the gdbarch_unwind_pc method adjusts
2045 it (we do not rely on the value, only on the unwound PC being
2046 dependent on this value). A potential improvement would be
2047 to have the frame prev_pc method and the gdbarch unwind_pc
2048 method set the same lval and location information as
2049 frame_register_unwind. */
2050 if (this_frame
->level
> 0
2051 && gdbarch_pc_regnum (gdbarch
) >= 0
2052 && get_frame_type (this_frame
) == NORMAL_FRAME
2053 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
2054 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
2056 int optimized
, realnum
, nrealnum
;
2057 enum lval_type lval
, nlval
;
2058 CORE_ADDR addr
, naddr
;
2060 frame_register_unwind_location (this_frame
,
2061 gdbarch_pc_regnum (gdbarch
),
2062 &optimized
, &lval
, &addr
, &realnum
);
2063 frame_register_unwind_location (get_next_frame (this_frame
),
2064 gdbarch_pc_regnum (gdbarch
),
2065 &optimized
, &nlval
, &naddr
, &nrealnum
);
2067 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2068 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2072 fprintf_unfiltered (gdb_stdlog
, "-> ");
2073 fprint_frame (gdb_stdlog
, NULL
);
2074 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
2077 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2078 this_frame
->prev
= NULL
;
2083 return get_prev_frame_if_no_cycle (this_frame
);
2086 /* Return a "struct frame_info" corresponding to the frame that called
2087 THIS_FRAME. Returns NULL if there is no such frame.
2089 Unlike get_prev_frame, this function always tries to unwind the
2093 get_prev_frame_always (struct frame_info
*this_frame
)
2095 struct frame_info
*prev_frame
= NULL
;
2099 prev_frame
= get_prev_frame_always_1 (this_frame
);
2101 CATCH (ex
, RETURN_MASK_ERROR
)
2103 if (ex
.error
== MEMORY_ERROR
)
2105 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2106 if (ex
.message
!= NULL
)
2111 /* The error needs to live as long as the frame does.
2112 Allocate using stack local STOP_STRING then assign the
2113 pointer to the frame, this allows the STOP_STRING on the
2114 frame to be of type 'const char *'. */
2115 size
= strlen (ex
.message
) + 1;
2116 stop_string
= (char *) frame_obstack_zalloc (size
);
2117 memcpy (stop_string
, ex
.message
, size
);
2118 this_frame
->stop_string
= stop_string
;
2123 throw_exception (ex
);
2130 /* Construct a new "struct frame_info" and link it previous to
2133 static struct frame_info
*
2134 get_prev_frame_raw (struct frame_info
*this_frame
)
2136 struct frame_info
*prev_frame
;
2138 /* Allocate the new frame but do not wire it in to the frame chain.
2139 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2140 frame->next to pull some fancy tricks (of course such code is, by
2141 definition, recursive). Try to prevent it.
2143 There is no reason to worry about memory leaks, should the
2144 remainder of the function fail. The allocated memory will be
2145 quickly reclaimed when the frame cache is flushed, and the `we've
2146 been here before' check above will stop repeated memory
2147 allocation calls. */
2148 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2149 prev_frame
->level
= this_frame
->level
+ 1;
2151 /* For now, assume we don't have frame chains crossing address
2153 prev_frame
->pspace
= this_frame
->pspace
;
2154 prev_frame
->aspace
= this_frame
->aspace
;
2156 /* Don't yet compute ->unwind (and hence ->type). It is computed
2157 on-demand in get_frame_type, frame_register_unwind, and
2160 /* Don't yet compute the frame's ID. It is computed on-demand by
2163 /* The unwound frame ID is validate at the start of this function,
2164 as part of the logic to decide if that frame should be further
2165 unwound, and not here while the prev frame is being created.
2166 Doing this makes it possible for the user to examine a frame that
2167 has an invalid frame ID.
2169 Some very old VAX code noted: [...] For the sake of argument,
2170 suppose that the stack is somewhat trashed (which is one reason
2171 that "info frame" exists). So, return 0 (indicating we don't
2172 know the address of the arglist) if we don't know what frame this
2176 this_frame
->prev
= prev_frame
;
2177 prev_frame
->next
= this_frame
;
2181 fprintf_unfiltered (gdb_stdlog
, "-> ");
2182 fprint_frame (gdb_stdlog
, prev_frame
);
2183 fprintf_unfiltered (gdb_stdlog
, " }\n");
2189 /* Debug routine to print a NULL frame being returned. */
2192 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2197 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2198 if (this_frame
!= NULL
)
2199 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2201 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2202 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2206 /* Is this (non-sentinel) frame in the "main"() function? */
2209 inside_main_func (struct frame_info
*this_frame
)
2211 struct bound_minimal_symbol msymbol
;
2214 if (symfile_objfile
== 0)
2216 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2217 if (msymbol
.minsym
== NULL
)
2219 /* Make certain that the code, and not descriptor, address is
2221 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2222 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2223 current_top_target ());
2224 return maddr
== get_frame_func (this_frame
);
2227 /* Test whether THIS_FRAME is inside the process entry point function. */
2230 inside_entry_func (struct frame_info
*this_frame
)
2232 CORE_ADDR entry_point
;
2234 if (!entry_point_address_query (&entry_point
))
2237 return get_frame_func (this_frame
) == entry_point
;
2240 /* Return a structure containing various interesting information about
2241 the frame that called THIS_FRAME. Returns NULL if there is entier
2242 no such frame or the frame fails any of a set of target-independent
2243 condition that should terminate the frame chain (e.g., as unwinding
2246 This function should not contain target-dependent tests, such as
2247 checking whether the program-counter is zero. */
2250 get_prev_frame (struct frame_info
*this_frame
)
2255 /* There is always a frame. If this assertion fails, suspect that
2256 something should be calling get_selected_frame() or
2257 get_current_frame(). */
2258 gdb_assert (this_frame
!= NULL
);
2260 /* If this_frame is the current frame, then compute and stash
2261 its frame id prior to fetching and computing the frame id of the
2262 previous frame. Otherwise, the cycle detection code in
2263 get_prev_frame_if_no_cycle() will not work correctly. When
2264 get_frame_id() is called later on, an assertion error will
2265 be triggered in the event of a cycle between the current
2266 frame and its previous frame. */
2267 if (this_frame
->level
== 0)
2268 get_frame_id (this_frame
);
2270 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2272 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2273 sense to stop unwinding at a dummy frame. One place where a dummy
2274 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2275 pcsqh register (space register for the instruction at the head of the
2276 instruction queue) cannot be written directly; the only way to set it
2277 is to branch to code that is in the target space. In order to implement
2278 frame dummies on HPUX, the called function is made to jump back to where
2279 the inferior was when the user function was called. If gdb was inside
2280 the main function when we created the dummy frame, the dummy frame will
2281 point inside the main function. */
2282 if (this_frame
->level
>= 0
2283 && get_frame_type (this_frame
) == NORMAL_FRAME
2284 && !backtrace_past_main
2286 && inside_main_func (this_frame
))
2287 /* Don't unwind past main(). Note, this is done _before_ the
2288 frame has been marked as previously unwound. That way if the
2289 user later decides to enable unwinds past main(), that will
2290 automatically happen. */
2292 frame_debug_got_null_frame (this_frame
, "inside main func");
2296 /* If the user's backtrace limit has been exceeded, stop. We must
2297 add two to the current level; one of those accounts for backtrace_limit
2298 being 1-based and the level being 0-based, and the other accounts for
2299 the level of the new frame instead of the level of the current
2301 if (this_frame
->level
+ 2 > backtrace_limit
)
2303 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2307 /* If we're already inside the entry function for the main objfile,
2308 then it isn't valid. Don't apply this test to a dummy frame -
2309 dummy frame PCs typically land in the entry func. Don't apply
2310 this test to the sentinel frame. Sentinel frames should always
2311 be allowed to unwind. */
2312 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2313 wasn't checking for "main" in the minimal symbols. With that
2314 fixed asm-source tests now stop in "main" instead of halting the
2315 backtrace in weird and wonderful ways somewhere inside the entry
2316 file. Suspect that tests for inside the entry file/func were
2317 added to work around that (now fixed) case. */
2318 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2319 suggested having the inside_entry_func test use the
2320 inside_main_func() msymbol trick (along with entry_point_address()
2321 I guess) to determine the address range of the start function.
2322 That should provide a far better stopper than the current
2324 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2325 applied tail-call optimizations to main so that a function called
2326 from main returns directly to the caller of main. Since we don't
2327 stop at main, we should at least stop at the entry point of the
2329 if (this_frame
->level
>= 0
2330 && get_frame_type (this_frame
) == NORMAL_FRAME
2331 && !backtrace_past_entry
2333 && inside_entry_func (this_frame
))
2335 frame_debug_got_null_frame (this_frame
, "inside entry func");
2339 /* Assume that the only way to get a zero PC is through something
2340 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2341 will never unwind a zero PC. */
2342 if (this_frame
->level
> 0
2343 && (get_frame_type (this_frame
) == NORMAL_FRAME
2344 || get_frame_type (this_frame
) == INLINE_FRAME
)
2345 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2346 && frame_pc_p
&& frame_pc
== 0)
2348 frame_debug_got_null_frame (this_frame
, "zero PC");
2352 return get_prev_frame_always (this_frame
);
2356 get_prev_frame_id_by_id (struct frame_id id
)
2358 struct frame_id prev_id
;
2359 struct frame_info
*frame
;
2361 frame
= frame_find_by_id (id
);
2364 prev_id
= get_frame_id (get_prev_frame (frame
));
2366 prev_id
= null_frame_id
;
2372 get_frame_pc (struct frame_info
*frame
)
2374 gdb_assert (frame
->next
!= NULL
);
2375 return frame_unwind_pc (frame
->next
);
2379 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2382 gdb_assert (frame
->next
!= NULL
);
2386 *pc
= frame_unwind_pc (frame
->next
);
2388 CATCH (ex
, RETURN_MASK_ERROR
)
2390 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2393 throw_exception (ex
);
2400 /* Return an address that falls within THIS_FRAME's code block. */
2403 get_frame_address_in_block (struct frame_info
*this_frame
)
2405 /* A draft address. */
2406 CORE_ADDR pc
= get_frame_pc (this_frame
);
2408 struct frame_info
*next_frame
= this_frame
->next
;
2410 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2411 Normally the resume address is inside the body of the function
2412 associated with THIS_FRAME, but there is a special case: when
2413 calling a function which the compiler knows will never return
2414 (for instance abort), the call may be the very last instruction
2415 in the calling function. The resume address will point after the
2416 call and may be at the beginning of a different function
2419 If THIS_FRAME is a signal frame or dummy frame, then we should
2420 not adjust the unwound PC. For a dummy frame, GDB pushed the
2421 resume address manually onto the stack. For a signal frame, the
2422 OS may have pushed the resume address manually and invoked the
2423 handler (e.g. GNU/Linux), or invoked the trampoline which called
2424 the signal handler - but in either case the signal handler is
2425 expected to return to the trampoline. So in both of these
2426 cases we know that the resume address is executable and
2427 related. So we only need to adjust the PC if THIS_FRAME
2428 is a normal function.
2430 If the program has been interrupted while THIS_FRAME is current,
2431 then clearly the resume address is inside the associated
2432 function. There are three kinds of interruption: debugger stop
2433 (next frame will be SENTINEL_FRAME), operating system
2434 signal or exception (next frame will be SIGTRAMP_FRAME),
2435 or debugger-induced function call (next frame will be
2436 DUMMY_FRAME). So we only need to adjust the PC if
2437 NEXT_FRAME is a normal function.
2439 We check the type of NEXT_FRAME first, since it is already
2440 known; frame type is determined by the unwinder, and since
2441 we have THIS_FRAME we've already selected an unwinder for
2444 If the next frame is inlined, we need to keep going until we find
2445 the real function - for instance, if a signal handler is invoked
2446 while in an inlined function, then the code address of the
2447 "calling" normal function should not be adjusted either. */
2449 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2450 next_frame
= next_frame
->next
;
2452 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2453 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2454 && (get_frame_type (this_frame
) == NORMAL_FRAME
2455 || get_frame_type (this_frame
) == TAILCALL_FRAME
2456 || get_frame_type (this_frame
) == INLINE_FRAME
))
2463 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2469 *pc
= get_frame_address_in_block (this_frame
);
2471 CATCH (ex
, RETURN_MASK_ERROR
)
2473 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2475 throw_exception (ex
);
2483 find_frame_sal (frame_info
*frame
)
2485 struct frame_info
*next_frame
;
2489 /* If the next frame represents an inlined function call, this frame's
2490 sal is the "call site" of that inlined function, which can not
2491 be inferred from get_frame_pc. */
2492 next_frame
= get_next_frame (frame
);
2493 if (frame_inlined_callees (frame
) > 0)
2498 sym
= get_frame_function (next_frame
);
2500 sym
= inline_skipped_symbol (inferior_thread ());
2502 /* If frame is inline, it certainly has symbols. */
2505 symtab_and_line sal
;
2506 if (SYMBOL_LINE (sym
) != 0)
2508 sal
.symtab
= symbol_symtab (sym
);
2509 sal
.line
= SYMBOL_LINE (sym
);
2512 /* If the symbol does not have a location, we don't know where
2513 the call site is. Do not pretend to. This is jarring, but
2514 we can't do much better. */
2515 sal
.pc
= get_frame_pc (frame
);
2517 sal
.pspace
= get_frame_program_space (frame
);
2521 /* If FRAME is not the innermost frame, that normally means that
2522 FRAME->pc points at the return instruction (which is *after* the
2523 call instruction), and we want to get the line containing the
2524 call (because the call is where the user thinks the program is).
2525 However, if the next frame is either a SIGTRAMP_FRAME or a
2526 DUMMY_FRAME, then the next frame will contain a saved interrupt
2527 PC and such a PC indicates the current (rather than next)
2528 instruction/line, consequently, for such cases, want to get the
2529 line containing fi->pc. */
2530 if (!get_frame_pc_if_available (frame
, &pc
))
2533 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2534 return find_pc_line (pc
, notcurrent
);
2537 /* Per "frame.h", return the ``address'' of the frame. Code should
2538 really be using get_frame_id(). */
2540 get_frame_base (struct frame_info
*fi
)
2542 return get_frame_id (fi
).stack_addr
;
2545 /* High-level offsets into the frame. Used by the debug info. */
2548 get_frame_base_address (struct frame_info
*fi
)
2550 if (get_frame_type (fi
) != NORMAL_FRAME
)
2552 if (fi
->base
== NULL
)
2553 fi
->base
= frame_base_find_by_frame (fi
);
2554 /* Sneaky: If the low-level unwind and high-level base code share a
2555 common unwinder, let them share the prologue cache. */
2556 if (fi
->base
->unwind
== fi
->unwind
)
2557 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2558 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2562 get_frame_locals_address (struct frame_info
*fi
)
2564 if (get_frame_type (fi
) != NORMAL_FRAME
)
2566 /* If there isn't a frame address method, find it. */
2567 if (fi
->base
== NULL
)
2568 fi
->base
= frame_base_find_by_frame (fi
);
2569 /* Sneaky: If the low-level unwind and high-level base code share a
2570 common unwinder, let them share the prologue cache. */
2571 if (fi
->base
->unwind
== fi
->unwind
)
2572 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2573 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2577 get_frame_args_address (struct frame_info
*fi
)
2579 if (get_frame_type (fi
) != NORMAL_FRAME
)
2581 /* If there isn't a frame address method, find it. */
2582 if (fi
->base
== NULL
)
2583 fi
->base
= frame_base_find_by_frame (fi
);
2584 /* Sneaky: If the low-level unwind and high-level base code share a
2585 common unwinder, let them share the prologue cache. */
2586 if (fi
->base
->unwind
== fi
->unwind
)
2587 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2588 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2591 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2595 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2597 if (fi
->unwind
== NULL
)
2598 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2599 return fi
->unwind
== unwinder
;
2602 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2603 or -1 for a NULL frame. */
2606 frame_relative_level (struct frame_info
*fi
)
2615 get_frame_type (struct frame_info
*frame
)
2617 if (frame
->unwind
== NULL
)
2618 /* Initialize the frame's unwinder because that's what
2619 provides the frame's type. */
2620 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2621 return frame
->unwind
->type
;
2624 struct program_space
*
2625 get_frame_program_space (struct frame_info
*frame
)
2627 return frame
->pspace
;
2630 struct program_space
*
2631 frame_unwind_program_space (struct frame_info
*this_frame
)
2633 gdb_assert (this_frame
);
2635 /* This is really a placeholder to keep the API consistent --- we
2636 assume for now that we don't have frame chains crossing
2638 return this_frame
->pspace
;
2641 const address_space
*
2642 get_frame_address_space (struct frame_info
*frame
)
2644 return frame
->aspace
;
2647 /* Memory access methods. */
2650 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2651 gdb_byte
*buf
, int len
)
2653 read_memory (addr
, buf
, len
);
2657 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2660 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2661 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2663 return read_memory_integer (addr
, len
, byte_order
);
2667 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2670 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2671 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2673 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2677 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2678 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2680 /* NOTE: target_read_memory returns zero on success! */
2681 return !target_read_memory (addr
, buf
, len
);
2684 /* Architecture methods. */
2687 get_frame_arch (struct frame_info
*this_frame
)
2689 return frame_unwind_arch (this_frame
->next
);
2693 frame_unwind_arch (struct frame_info
*next_frame
)
2695 if (!next_frame
->prev_arch
.p
)
2697 struct gdbarch
*arch
;
2699 if (next_frame
->unwind
== NULL
)
2700 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2702 if (next_frame
->unwind
->prev_arch
!= NULL
)
2703 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2704 &next_frame
->prologue_cache
);
2706 arch
= get_frame_arch (next_frame
);
2708 next_frame
->prev_arch
.arch
= arch
;
2709 next_frame
->prev_arch
.p
= 1;
2711 fprintf_unfiltered (gdb_stdlog
,
2712 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2714 gdbarch_bfd_arch_info (arch
)->printable_name
);
2717 return next_frame
->prev_arch
.arch
;
2721 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2723 next_frame
= skip_artificial_frames (next_frame
);
2725 /* We must have a non-artificial frame. The caller is supposed to check
2726 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2728 gdb_assert (next_frame
!= NULL
);
2730 return frame_unwind_arch (next_frame
);
2733 /* Gets the language of FRAME. */
2736 get_frame_language (struct frame_info
*frame
)
2741 gdb_assert (frame
!= NULL
);
2743 /* We determine the current frame language by looking up its
2744 associated symtab. To retrieve this symtab, we use the frame
2745 PC. However we cannot use the frame PC as is, because it
2746 usually points to the instruction following the "call", which
2747 is sometimes the first instruction of another function. So
2748 we rely on get_frame_address_in_block(), it provides us with
2749 a PC that is guaranteed to be inside the frame's code
2754 pc
= get_frame_address_in_block (frame
);
2757 CATCH (ex
, RETURN_MASK_ERROR
)
2759 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2760 throw_exception (ex
);
2766 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2769 return compunit_language (cust
);
2772 return language_unknown
;
2775 /* Stack pointer methods. */
2778 get_frame_sp (struct frame_info
*this_frame
)
2780 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2782 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2783 operate on THIS_FRAME now. */
2784 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2787 /* Return the reason why we can't unwind past FRAME. */
2789 enum unwind_stop_reason
2790 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2792 /* Fill-in STOP_REASON. */
2793 get_prev_frame_always (frame
);
2794 gdb_assert (frame
->prev_p
);
2796 return frame
->stop_reason
;
2799 /* Return a string explaining REASON. */
2802 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2806 #define SET(name, description) \
2807 case name: return _(description);
2808 #include "unwind_stop_reasons.def"
2812 internal_error (__FILE__
, __LINE__
,
2813 "Invalid frame stop reason");
2818 frame_stop_reason_string (struct frame_info
*fi
)
2820 gdb_assert (fi
->prev_p
);
2821 gdb_assert (fi
->prev
== NULL
);
2823 /* Return the specific string if we have one. */
2824 if (fi
->stop_string
!= NULL
)
2825 return fi
->stop_string
;
2827 /* Return the generic string if we have nothing better. */
2828 return unwind_stop_reason_to_string (fi
->stop_reason
);
2831 /* Return the enum symbol name of REASON as a string, to use in debug
2835 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2839 #define SET(name, description) \
2840 case name: return #name;
2841 #include "unwind_stop_reasons.def"
2845 internal_error (__FILE__
, __LINE__
,
2846 "Invalid frame stop reason");
2850 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2854 frame_cleanup_after_sniffer (struct frame_info
*frame
)
2856 /* The sniffer should not allocate a prologue cache if it did not
2857 match this frame. */
2858 gdb_assert (frame
->prologue_cache
== NULL
);
2860 /* No sniffer should extend the frame chain; sniff based on what is
2862 gdb_assert (!frame
->prev_p
);
2864 /* The sniffer should not check the frame's ID; that's circular. */
2865 gdb_assert (!frame
->this_id
.p
);
2867 /* Clear cached fields dependent on the unwinder.
2869 The previous PC is independent of the unwinder, but the previous
2870 function is not (see get_frame_address_in_block). */
2871 frame
->prev_func
.p
= 0;
2872 frame
->prev_func
.addr
= 0;
2874 /* Discard the unwinder last, so that we can easily find it if an assertion
2875 in this function triggers. */
2876 frame
->unwind
= NULL
;
2879 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2880 If sniffing fails, the caller should be sure to call
2881 frame_cleanup_after_sniffer. */
2884 frame_prepare_for_sniffer (struct frame_info
*frame
,
2885 const struct frame_unwind
*unwind
)
2887 gdb_assert (frame
->unwind
== NULL
);
2888 frame
->unwind
= unwind
;
2891 static struct cmd_list_element
*set_backtrace_cmdlist
;
2892 static struct cmd_list_element
*show_backtrace_cmdlist
;
2895 set_backtrace_cmd (const char *args
, int from_tty
)
2897 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2902 show_backtrace_cmd (const char *args
, int from_tty
)
2904 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2908 _initialize_frame (void)
2910 obstack_init (&frame_cache_obstack
);
2912 frame_stash_create ();
2914 gdb::observers::target_changed
.attach (frame_observer_target_changed
);
2916 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2917 Set backtrace specific variables.\n\
2918 Configure backtrace variables such as the backtrace limit"),
2919 &set_backtrace_cmdlist
, "set backtrace ",
2920 0/*allow-unknown*/, &setlist
);
2921 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2922 Show backtrace specific variables\n\
2923 Show backtrace variables such as the backtrace limit"),
2924 &show_backtrace_cmdlist
, "show backtrace ",
2925 0/*allow-unknown*/, &showlist
);
2927 add_setshow_boolean_cmd ("past-main", class_obscure
,
2928 &backtrace_past_main
, _("\
2929 Set whether backtraces should continue past \"main\"."), _("\
2930 Show whether backtraces should continue past \"main\"."), _("\
2931 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2932 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2933 of the stack trace."),
2935 show_backtrace_past_main
,
2936 &set_backtrace_cmdlist
,
2937 &show_backtrace_cmdlist
);
2939 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2940 &backtrace_past_entry
, _("\
2941 Set whether backtraces should continue past the entry point of a program."),
2943 Show whether backtraces should continue past the entry point of a program."),
2945 Normally there are no callers beyond the entry point of a program, so GDB\n\
2946 will terminate the backtrace there. Set this variable if you need to see\n\
2947 the rest of the stack trace."),
2949 show_backtrace_past_entry
,
2950 &set_backtrace_cmdlist
,
2951 &show_backtrace_cmdlist
);
2953 add_setshow_uinteger_cmd ("limit", class_obscure
,
2954 &backtrace_limit
, _("\
2955 Set an upper bound on the number of backtrace levels."), _("\
2956 Show the upper bound on the number of backtrace levels."), _("\
2957 No more than the specified number of frames can be displayed or examined.\n\
2958 Literal \"unlimited\" or zero means no limit."),
2960 show_backtrace_limit
,
2961 &set_backtrace_cmdlist
,
2962 &show_backtrace_cmdlist
);
2964 /* Debug this files internals. */
2965 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2966 Set frame debugging."), _("\
2967 Show frame debugging."), _("\
2968 When non-zero, frame specific internal debugging is enabled."),
2971 &setdebuglist
, &showdebuglist
);