1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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/>. */
24 #include "inferior.h" /* for inferior_ptid */
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
37 #include "observable.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
46 /* The sentinel frame terminates the innermost end of the frame chain.
47 If unwound, it returns the information needed to construct an
50 The current frame, which is the innermost frame, can be found at
51 sentinel_frame->prev. */
53 static struct frame_info
*sentinel_frame
;
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
);
58 /* Status of some values cached in the frame_info object. */
60 enum cached_copy_status
62 /* Value is unknown. */
65 /* We have a value. */
68 /* Value was not saved. */
71 /* Value is unavailable. */
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. */
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
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. */
98 /* The frame's program space. */
99 struct program_space
*pspace
;
101 /* The frame's address space. */
102 const address_space
*aspace
;
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
;
112 /* Cached copy of the previous frame's architecture. */
116 struct gdbarch
*arch
;
119 /* Cached copy of the previous frame's resume address. */
121 enum cached_copy_status status
;
125 /* Cached copy of the previous frame's function address. */
132 /* This frame's ID. */
136 struct frame_id value
;
139 /* The frame's high-level base methods, and corresponding cache.
140 The high level base methods are selected based on the frame's
142 const struct frame_base
*base
;
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 */
149 struct frame_info
*prev
; /* up, outer, older */
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
;
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
;
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. */
165 static htab_t frame_stash
;
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. */
172 frame_addr_hash (const void *ap
)
174 const struct frame_info
*frame
= (const struct frame_info
*) ap
;
175 const struct frame_id f_id
= frame
->this_id
.value
;
178 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
180 || f_id
.special_addr_p
);
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
);
195 /* Internal equality function for the hash table. This function
196 defers equality operations to frame_id_eq. */
199 frame_addr_hash_eq (const void *a
, const void *b
)
201 const struct frame_info
*f_entry
= (const struct frame_info
*) a
;
202 const struct frame_info
*f_element
= (const struct frame_info
*) b
;
204 return frame_id_eq (f_entry
->this_id
.value
,
205 f_element
->this_id
.value
);
208 /* Internal function to create the frame_stash hash table. 100 seems
209 to be a good compromise to start the hash table at. */
212 frame_stash_create (void)
214 frame_stash
= htab_create (100,
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
225 frame_stash_add (struct frame_info
*frame
)
227 struct frame_info
**slot
;
229 /* Do not try to stash the sentinel frame. */
230 gdb_assert (frame
->level
>= 0);
232 slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
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. */
247 /* Internal function to search the frame stash for an entry with the
248 given frame ID. If found, return that frame. Otherwise return
251 static struct frame_info
*
252 frame_stash_find (struct frame_id id
)
254 struct frame_info dummy
;
255 struct frame_info
*frame
;
257 dummy
.this_id
.value
= id
;
258 frame
= (struct frame_info
*) htab_find (frame_stash
, &dummy
);
262 /* Internal function to invalidate the frame stash by removing all
263 entries in it. This only occurs when the frame cache is
267 frame_stash_invalidate (void)
269 htab_empty (frame_stash
);
273 scoped_restore_selected_frame::scoped_restore_selected_frame ()
275 m_fid
= get_frame_id (get_selected_frame (NULL
));
279 scoped_restore_selected_frame::~scoped_restore_selected_frame ()
281 frame_info
*frame
= frame_find_by_id (m_fid
);
283 warning (_("Unable to restore previously selected frame."));
285 select_frame (frame
);
288 /* Flag to control debugging. */
290 unsigned int frame_debug
;
292 show_frame_debug (struct ui_file
*file
, int from_tty
,
293 struct cmd_list_element
*c
, const char *value
)
295 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
298 /* Flag to indicate whether backtraces should stop at main et.al. */
300 static int backtrace_past_main
;
302 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
303 struct cmd_list_element
*c
, const char *value
)
305 fprintf_filtered (file
,
306 _("Whether backtraces should "
307 "continue past \"main\" is %s.\n"),
311 static int backtrace_past_entry
;
313 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
314 struct cmd_list_element
*c
, const char *value
)
316 fprintf_filtered (file
, _("Whether backtraces should continue past the "
317 "entry point of a program is %s.\n"),
321 static unsigned int backtrace_limit
= UINT_MAX
;
323 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
324 struct cmd_list_element
*c
, const char *value
)
326 fprintf_filtered (file
,
327 _("An upper bound on the number "
328 "of backtrace levels is %s.\n"),
334 fprint_field (struct ui_file
*file
, const char *name
, int p
, CORE_ADDR addr
)
337 fprintf_unfiltered (file
, "%s=%s", name
, hex_string (addr
));
339 fprintf_unfiltered (file
, "!%s", name
);
343 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
345 fprintf_unfiltered (file
, "{");
347 if (id
.stack_status
== FID_STACK_INVALID
)
348 fprintf_unfiltered (file
, "!stack");
349 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
350 fprintf_unfiltered (file
, "stack=<unavailable>");
351 else if (id
.stack_status
== FID_STACK_SENTINEL
)
352 fprintf_unfiltered (file
, "stack=<sentinel>");
354 fprintf_unfiltered (file
, "stack=%s", hex_string (id
.stack_addr
));
355 fprintf_unfiltered (file
, ",");
357 fprint_field (file
, "code", id
.code_addr_p
, id
.code_addr
);
358 fprintf_unfiltered (file
, ",");
360 fprint_field (file
, "special", id
.special_addr_p
, id
.special_addr
);
362 if (id
.artificial_depth
)
363 fprintf_unfiltered (file
, ",artificial=%d", id
.artificial_depth
);
365 fprintf_unfiltered (file
, "}");
369 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
374 fprintf_unfiltered (file
, "NORMAL_FRAME");
377 fprintf_unfiltered (file
, "DUMMY_FRAME");
380 fprintf_unfiltered (file
, "INLINE_FRAME");
383 fprintf_unfiltered (file
, "TAILCALL_FRAME");
386 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
389 fprintf_unfiltered (file
, "ARCH_FRAME");
392 fprintf_unfiltered (file
, "SENTINEL_FRAME");
395 fprintf_unfiltered (file
, "<unknown type>");
401 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
405 fprintf_unfiltered (file
, "<NULL frame>");
408 fprintf_unfiltered (file
, "{");
409 fprintf_unfiltered (file
, "level=%d", fi
->level
);
410 fprintf_unfiltered (file
, ",");
411 fprintf_unfiltered (file
, "type=");
412 if (fi
->unwind
!= NULL
)
413 fprint_frame_type (file
, fi
->unwind
->type
);
415 fprintf_unfiltered (file
, "<unknown>");
416 fprintf_unfiltered (file
, ",");
417 fprintf_unfiltered (file
, "unwind=");
418 if (fi
->unwind
!= NULL
)
419 gdb_print_host_address (fi
->unwind
, file
);
421 fprintf_unfiltered (file
, "<unknown>");
422 fprintf_unfiltered (file
, ",");
423 fprintf_unfiltered (file
, "pc=");
424 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
425 fprintf_unfiltered (file
, "<unknown>");
426 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
427 fprintf_unfiltered (file
, "%s",
428 hex_string (fi
->next
->prev_pc
.value
));
429 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
430 val_print_not_saved (file
);
431 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
432 val_print_unavailable (file
);
433 fprintf_unfiltered (file
, ",");
434 fprintf_unfiltered (file
, "id=");
436 fprint_frame_id (file
, fi
->this_id
.value
);
438 fprintf_unfiltered (file
, "<unknown>");
439 fprintf_unfiltered (file
, ",");
440 fprintf_unfiltered (file
, "func=");
441 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
442 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
444 fprintf_unfiltered (file
, "<unknown>");
445 fprintf_unfiltered (file
, "}");
448 /* Given FRAME, return the enclosing frame as found in real frames read-in from
449 inferior memory. Skip any previous frames which were made up by GDB.
450 Return FRAME if FRAME is a non-artificial frame.
451 Return NULL if FRAME is the start of an artificial-only chain. */
453 static struct frame_info
*
454 skip_artificial_frames (struct frame_info
*frame
)
456 /* Note we use get_prev_frame_always, and not get_prev_frame. The
457 latter will truncate the frame chain, leading to this function
458 unintentionally returning a null_frame_id (e.g., when the user
459 sets a backtrace limit).
461 Note that for record targets we may get a frame chain that consists
462 of artificial frames only. */
463 while (get_frame_type (frame
) == INLINE_FRAME
464 || get_frame_type (frame
) == TAILCALL_FRAME
)
466 frame
= get_prev_frame_always (frame
);
475 skip_unwritable_frames (struct frame_info
*frame
)
477 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
479 frame
= get_prev_frame (frame
);
490 skip_tailcall_frames (struct frame_info
*frame
)
492 while (get_frame_type (frame
) == TAILCALL_FRAME
)
494 /* Note that for record targets we may get a frame chain that consists of
495 tailcall frames only. */
496 frame
= get_prev_frame (frame
);
504 /* Compute the frame's uniq ID that can be used to, later, re-find the
508 compute_frame_id (struct frame_info
*fi
)
510 gdb_assert (!fi
->this_id
.p
);
513 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
515 /* Find the unwinder. */
516 if (fi
->unwind
== NULL
)
517 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
518 /* Find THIS frame's ID. */
519 /* Default to outermost if no ID is found. */
520 fi
->this_id
.value
= outer_frame_id
;
521 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
522 gdb_assert (frame_id_p (fi
->this_id
.value
));
526 fprintf_unfiltered (gdb_stdlog
, "-> ");
527 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
528 fprintf_unfiltered (gdb_stdlog
, " }\n");
532 /* Return a frame uniq ID that can be used to, later, re-find the
536 get_frame_id (struct frame_info
*fi
)
539 return null_frame_id
;
545 /* If we haven't computed the frame id yet, then it must be that
546 this is the current frame. Compute it now, and stash the
547 result. The IDs of other frames are computed as soon as
548 they're created, in order to detect cycles. See
549 get_prev_frame_if_no_cycle. */
550 gdb_assert (fi
->level
== 0);
553 compute_frame_id (fi
);
555 /* Since this is the first frame in the chain, this should
557 stashed
= frame_stash_add (fi
);
558 gdb_assert (stashed
);
561 return fi
->this_id
.value
;
565 get_stack_frame_id (struct frame_info
*next_frame
)
567 return get_frame_id (skip_artificial_frames (next_frame
));
571 frame_unwind_caller_id (struct frame_info
*next_frame
)
573 struct frame_info
*this_frame
;
575 /* Use get_prev_frame_always, and not get_prev_frame. The latter
576 will truncate the frame chain, leading to this function
577 unintentionally returning a null_frame_id (e.g., when a caller
578 requests the frame ID of "main()"s caller. */
580 next_frame
= skip_artificial_frames (next_frame
);
581 if (next_frame
== NULL
)
582 return null_frame_id
;
584 this_frame
= get_prev_frame_always (next_frame
);
586 return get_frame_id (skip_artificial_frames (this_frame
));
588 return null_frame_id
;
591 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
592 const struct frame_id sentinel_frame_id
= { 0, 0, 0, FID_STACK_SENTINEL
, 0, 1, 0 };
593 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_INVALID
, 0, 1, 0 };
596 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
597 CORE_ADDR special_addr
)
599 struct frame_id id
= null_frame_id
;
601 id
.stack_addr
= stack_addr
;
602 id
.stack_status
= FID_STACK_VALID
;
603 id
.code_addr
= code_addr
;
605 id
.special_addr
= special_addr
;
606 id
.special_addr_p
= 1;
613 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
615 struct frame_id id
= null_frame_id
;
617 id
.stack_status
= FID_STACK_UNAVAILABLE
;
618 id
.code_addr
= code_addr
;
626 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
627 CORE_ADDR special_addr
)
629 struct frame_id id
= null_frame_id
;
631 id
.stack_status
= FID_STACK_UNAVAILABLE
;
632 id
.code_addr
= code_addr
;
634 id
.special_addr
= special_addr
;
635 id
.special_addr_p
= 1;
640 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
642 struct frame_id id
= null_frame_id
;
644 id
.stack_addr
= stack_addr
;
645 id
.stack_status
= FID_STACK_VALID
;
646 id
.code_addr
= code_addr
;
652 frame_id_build_wild (CORE_ADDR stack_addr
)
654 struct frame_id id
= null_frame_id
;
656 id
.stack_addr
= stack_addr
;
657 id
.stack_status
= FID_STACK_VALID
;
662 frame_id_p (struct frame_id l
)
666 /* The frame is valid iff it has a valid stack address. */
667 p
= l
.stack_status
!= FID_STACK_INVALID
;
668 /* outer_frame_id is also valid. */
669 if (!p
&& memcmp (&l
, &outer_frame_id
, sizeof (l
)) == 0)
673 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
674 fprint_frame_id (gdb_stdlog
, l
);
675 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
681 frame_id_artificial_p (struct frame_id l
)
686 return (l
.artificial_depth
!= 0);
690 frame_id_eq (struct frame_id l
, struct frame_id r
)
694 if (l
.stack_status
== FID_STACK_INVALID
&& l
.special_addr_p
695 && r
.stack_status
== FID_STACK_INVALID
&& r
.special_addr_p
)
696 /* The outermost frame marker is equal to itself. This is the
697 dodgy thing about outer_frame_id, since between execution steps
698 we might step into another function - from which we can't
699 unwind either. More thought required to get rid of
702 else if (l
.stack_status
== FID_STACK_INVALID
703 || r
.stack_status
== FID_STACK_INVALID
)
704 /* Like a NaN, if either ID is invalid, the result is false.
705 Note that a frame ID is invalid iff it is the null frame ID. */
707 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
708 /* If .stack addresses are different, the frames are different. */
710 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
711 /* An invalid code addr is a wild card. If .code addresses are
712 different, the frames are different. */
714 else if (l
.special_addr_p
&& r
.special_addr_p
715 && l
.special_addr
!= r
.special_addr
)
716 /* An invalid special addr is a wild card (or unused). Otherwise
717 if special addresses are different, the frames are different. */
719 else if (l
.artificial_depth
!= r
.artificial_depth
)
720 /* If artifical depths are different, the frames must be different. */
723 /* Frames are equal. */
728 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
729 fprint_frame_id (gdb_stdlog
, l
);
730 fprintf_unfiltered (gdb_stdlog
, ",r=");
731 fprint_frame_id (gdb_stdlog
, r
);
732 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
737 /* Safety net to check whether frame ID L should be inner to
738 frame ID R, according to their stack addresses.
740 This method cannot be used to compare arbitrary frames, as the
741 ranges of valid stack addresses may be discontiguous (e.g. due
744 However, it can be used as safety net to discover invalid frame
745 IDs in certain circumstances. Assuming that NEXT is the immediate
746 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
748 * The stack address of NEXT must be inner-than-or-equal to the stack
751 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
754 * If NEXT and THIS have different stack addresses, no other frame
755 in the frame chain may have a stack address in between.
757 Therefore, if frame_id_inner (TEST, THIS) holds, but
758 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
759 to a valid frame in the frame chain.
761 The sanity checks above cannot be performed when a SIGTRAMP frame
762 is involved, because signal handlers might be executed on a different
763 stack than the stack used by the routine that caused the signal
764 to be raised. This can happen for instance when a thread exceeds
765 its maximum stack size. In this case, certain compilers implement
766 a stack overflow strategy that cause the handler to be run on a
770 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
774 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
775 /* Like NaN, any operation involving an invalid ID always fails.
776 Likewise if either ID has an unavailable stack address. */
778 else if (l
.artificial_depth
> r
.artificial_depth
779 && l
.stack_addr
== r
.stack_addr
780 && l
.code_addr_p
== r
.code_addr_p
781 && l
.special_addr_p
== r
.special_addr_p
782 && l
.special_addr
== r
.special_addr
)
784 /* Same function, different inlined functions. */
785 const struct block
*lb
, *rb
;
787 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
789 lb
= block_for_pc (l
.code_addr
);
790 rb
= block_for_pc (r
.code_addr
);
792 if (lb
== NULL
|| rb
== NULL
)
793 /* Something's gone wrong. */
796 /* This will return true if LB and RB are the same block, or
797 if the block with the smaller depth lexically encloses the
798 block with the greater depth. */
799 inner
= contained_in (lb
, rb
);
802 /* Only return non-zero when strictly inner than. Note that, per
803 comment in "frame.h", there is some fuzz here. Frameless
804 functions are not strictly inner than (same .stack but
805 different .code and/or .special address). */
806 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
809 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
810 fprint_frame_id (gdb_stdlog
, l
);
811 fprintf_unfiltered (gdb_stdlog
, ",r=");
812 fprint_frame_id (gdb_stdlog
, r
);
813 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
819 frame_find_by_id (struct frame_id id
)
821 struct frame_info
*frame
, *prev_frame
;
823 /* ZERO denotes the null frame, let the caller decide what to do
824 about it. Should it instead return get_current_frame()? */
825 if (!frame_id_p (id
))
828 /* Check for the sentinel frame. */
829 if (frame_id_eq (id
, sentinel_frame_id
))
830 return sentinel_frame
;
832 /* Try using the frame stash first. Finding it there removes the need
833 to perform the search by looping over all frames, which can be very
834 CPU-intensive if the number of frames is very high (the loop is O(n)
835 and get_prev_frame performs a series of checks that are relatively
836 expensive). This optimization is particularly useful when this function
837 is called from another function (such as value_fetch_lazy, case
838 VALUE_LVAL (val) == lval_register) which already loops over all frames,
839 making the overall behavior O(n^2). */
840 frame
= frame_stash_find (id
);
844 for (frame
= get_current_frame (); ; frame
= prev_frame
)
846 struct frame_id self
= get_frame_id (frame
);
848 if (frame_id_eq (id
, self
))
849 /* An exact match. */
852 prev_frame
= get_prev_frame (frame
);
856 /* As a safety net to avoid unnecessary backtracing while trying
857 to find an invalid ID, we check for a common situation where
858 we can detect from comparing stack addresses that no other
859 frame in the current frame chain can have this ID. See the
860 comment at frame_id_inner for details. */
861 if (get_frame_type (frame
) == NORMAL_FRAME
862 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
863 && frame_id_inner (get_frame_arch (prev_frame
), id
,
864 get_frame_id (prev_frame
)))
871 frame_unwind_pc (struct frame_info
*this_frame
)
873 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
875 if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame
)))
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 internal_error (__FILE__
, __LINE__
, _("No unwind_pc method"));
947 if (this_frame
->prev_pc
.status
== CC_VALUE
)
948 return this_frame
->prev_pc
.value
;
949 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
950 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
951 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
952 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
954 internal_error (__FILE__
, __LINE__
,
955 "unexpected prev_pc status: %d",
956 (int) this_frame
->prev_pc
.status
);
960 frame_unwind_caller_pc (struct frame_info
*this_frame
)
962 this_frame
= skip_artificial_frames (this_frame
);
964 /* We must have a non-artificial frame. The caller is supposed to check
965 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
967 gdb_assert (this_frame
!= NULL
);
969 return frame_unwind_pc (this_frame
);
973 get_frame_func_if_available (struct frame_info
*this_frame
, CORE_ADDR
*pc
)
975 struct frame_info
*next_frame
= this_frame
->next
;
977 if (!next_frame
->prev_func
.p
)
979 CORE_ADDR addr_in_block
;
981 /* Make certain that this, and not the adjacent, function is
983 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
985 next_frame
->prev_func
.p
= -1;
987 fprintf_unfiltered (gdb_stdlog
,
988 "{ get_frame_func (this_frame=%d)"
989 " -> unavailable }\n",
994 next_frame
->prev_func
.p
= 1;
995 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
997 fprintf_unfiltered (gdb_stdlog
,
998 "{ get_frame_func (this_frame=%d) -> %s }\n",
1000 hex_string (next_frame
->prev_func
.addr
));
1004 if (next_frame
->prev_func
.p
< 0)
1011 *pc
= next_frame
->prev_func
.addr
;
1017 get_frame_func (struct frame_info
*this_frame
)
1021 if (!get_frame_func_if_available (this_frame
, &pc
))
1022 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1027 static enum register_status
1028 do_frame_register_read (void *src
, int regnum
, gdb_byte
*buf
)
1030 if (!deprecated_frame_register_read ((struct frame_info
*) src
, regnum
, buf
))
1031 return REG_UNAVAILABLE
;
1036 std::unique_ptr
<readonly_detached_regcache
>
1037 frame_save_as_regcache (struct frame_info
*this_frame
)
1039 std::unique_ptr
<readonly_detached_regcache
> regcache
1040 (new readonly_detached_regcache (get_frame_arch (this_frame
),
1041 do_frame_register_read
, this_frame
));
1047 frame_pop (struct frame_info
*this_frame
)
1049 struct frame_info
*prev_frame
;
1051 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1053 /* Popping a dummy frame involves restoring more than just registers.
1054 dummy_frame_pop does all the work. */
1055 dummy_frame_pop (get_frame_id (this_frame
), inferior_ptid
);
1059 /* Ensure that we have a frame to pop to. */
1060 prev_frame
= get_prev_frame_always (this_frame
);
1063 error (_("Cannot pop the initial frame."));
1065 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1066 entering THISFRAME. */
1067 prev_frame
= skip_tailcall_frames (prev_frame
);
1069 if (prev_frame
== NULL
)
1070 error (_("Cannot find the caller frame."));
1072 /* Make a copy of all the register values unwound from this frame.
1073 Save them in a scratch buffer so that there isn't a race between
1074 trying to extract the old values from the current regcache while
1075 at the same time writing new values into that same cache. */
1076 std::unique_ptr
<readonly_detached_regcache
> scratch
1077 = frame_save_as_regcache (prev_frame
);
1079 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1080 target's register cache that it is about to be hit with a burst
1081 register transfer and that the sequence of register writes should
1082 be batched. The pair target_prepare_to_store() and
1083 target_store_registers() kind of suggest this functionality.
1084 Unfortunately, they don't implement it. Their lack of a formal
1085 definition can lead to targets writing back bogus values
1086 (arguably a bug in the target code mind). */
1087 /* Now copy those saved registers into the current regcache. */
1088 get_current_regcache ()->restore (scratch
.get ());
1090 /* We've made right mess of GDB's local state, just discard
1092 reinit_frame_cache ();
1096 frame_register_unwind (struct frame_info
*frame
, int regnum
,
1097 int *optimizedp
, int *unavailablep
,
1098 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1099 int *realnump
, gdb_byte
*bufferp
)
1101 struct value
*value
;
1103 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1104 that the value proper does not need to be fetched. */
1105 gdb_assert (optimizedp
!= NULL
);
1106 gdb_assert (lvalp
!= NULL
);
1107 gdb_assert (addrp
!= NULL
);
1108 gdb_assert (realnump
!= NULL
);
1109 /* gdb_assert (bufferp != NULL); */
1111 value
= frame_unwind_register_value (frame
, regnum
);
1113 gdb_assert (value
!= NULL
);
1115 *optimizedp
= value_optimized_out (value
);
1116 *unavailablep
= !value_entirely_available (value
);
1117 *lvalp
= VALUE_LVAL (value
);
1118 *addrp
= value_address (value
);
1119 if (*lvalp
== lval_register
)
1120 *realnump
= VALUE_REGNUM (value
);
1126 if (!*optimizedp
&& !*unavailablep
)
1127 memcpy (bufferp
, value_contents_all (value
),
1128 TYPE_LENGTH (value_type (value
)));
1130 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1133 /* Dispose of the new value. This prevents watchpoints from
1134 trying to watch the saved frame pointer. */
1135 release_value (value
);
1139 frame_register (struct frame_info
*frame
, int regnum
,
1140 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1141 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1143 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1144 that the value proper does not need to be fetched. */
1145 gdb_assert (optimizedp
!= NULL
);
1146 gdb_assert (lvalp
!= NULL
);
1147 gdb_assert (addrp
!= NULL
);
1148 gdb_assert (realnump
!= NULL
);
1149 /* gdb_assert (bufferp != NULL); */
1151 /* Obtain the register value by unwinding the register from the next
1152 (more inner frame). */
1153 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1154 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1155 lvalp
, addrp
, realnump
, bufferp
);
1159 frame_unwind_register (struct frame_info
*frame
, int regnum
, gdb_byte
*buf
)
1165 enum lval_type lval
;
1167 frame_register_unwind (frame
, regnum
, &optimized
, &unavailable
,
1168 &lval
, &addr
, &realnum
, buf
);
1171 throw_error (OPTIMIZED_OUT_ERROR
,
1172 _("Register %d was not saved"), regnum
);
1174 throw_error (NOT_AVAILABLE_ERROR
,
1175 _("Register %d is not available"), regnum
);
1179 get_frame_register (struct frame_info
*frame
,
1180 int regnum
, gdb_byte
*buf
)
1182 frame_unwind_register (frame
->next
, regnum
, buf
);
1186 frame_unwind_register_value (struct frame_info
*frame
, int regnum
)
1188 struct gdbarch
*gdbarch
;
1189 struct value
*value
;
1191 gdb_assert (frame
!= NULL
);
1192 gdbarch
= frame_unwind_arch (frame
);
1196 fprintf_unfiltered (gdb_stdlog
,
1197 "{ frame_unwind_register_value "
1198 "(frame=%d,regnum=%d(%s),...) ",
1199 frame
->level
, regnum
,
1200 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1203 /* Find the unwinder. */
1204 if (frame
->unwind
== NULL
)
1205 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
1207 /* Ask this frame to unwind its register. */
1208 value
= frame
->unwind
->prev_register (frame
, &frame
->prologue_cache
, regnum
);
1212 fprintf_unfiltered (gdb_stdlog
, "->");
1213 if (value_optimized_out (value
))
1215 fprintf_unfiltered (gdb_stdlog
, " ");
1216 val_print_optimized_out (value
, gdb_stdlog
);
1220 if (VALUE_LVAL (value
) == lval_register
)
1221 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1222 VALUE_REGNUM (value
));
1223 else if (VALUE_LVAL (value
) == lval_memory
)
1224 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1226 value_address (value
)));
1228 fprintf_unfiltered (gdb_stdlog
, " computed");
1230 if (value_lazy (value
))
1231 fprintf_unfiltered (gdb_stdlog
, " lazy");
1235 const gdb_byte
*buf
= value_contents (value
);
1237 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1238 fprintf_unfiltered (gdb_stdlog
, "[");
1239 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1240 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1241 fprintf_unfiltered (gdb_stdlog
, "]");
1245 fprintf_unfiltered (gdb_stdlog
, " }\n");
1252 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1254 return frame_unwind_register_value (frame
->next
, regnum
);
1258 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
1260 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1261 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1262 int size
= register_size (gdbarch
, regnum
);
1263 struct value
*value
= frame_unwind_register_value (frame
, regnum
);
1265 gdb_assert (value
!= NULL
);
1267 if (value_optimized_out (value
))
1269 throw_error (OPTIMIZED_OUT_ERROR
,
1270 _("Register %d was not saved"), regnum
);
1272 if (!value_entirely_available (value
))
1274 throw_error (NOT_AVAILABLE_ERROR
,
1275 _("Register %d is not available"), regnum
);
1278 LONGEST r
= extract_signed_integer (value_contents_all (value
), size
,
1281 release_value (value
);
1286 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1288 return frame_unwind_register_signed (frame
->next
, regnum
);
1292 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
1294 struct gdbarch
*gdbarch
= frame_unwind_arch (frame
);
1295 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1296 int size
= register_size (gdbarch
, regnum
);
1297 struct value
*value
= frame_unwind_register_value (frame
, regnum
);
1299 gdb_assert (value
!= NULL
);
1301 if (value_optimized_out (value
))
1303 throw_error (OPTIMIZED_OUT_ERROR
,
1304 _("Register %d was not saved"), regnum
);
1306 if (!value_entirely_available (value
))
1308 throw_error (NOT_AVAILABLE_ERROR
,
1309 _("Register %d is not available"), regnum
);
1312 ULONGEST r
= extract_unsigned_integer (value_contents_all (value
), size
,
1315 release_value (value
);
1320 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1322 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1326 read_frame_register_unsigned (struct frame_info
*frame
, int regnum
,
1329 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1331 if (!value_optimized_out (regval
)
1332 && value_entirely_available (regval
))
1334 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1335 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1336 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1338 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1346 put_frame_register (struct frame_info
*frame
, int regnum
,
1347 const gdb_byte
*buf
)
1349 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1353 enum lval_type lval
;
1356 frame_register (frame
, regnum
, &optim
, &unavail
,
1357 &lval
, &addr
, &realnum
, NULL
);
1359 error (_("Attempt to assign to a register that was not saved."));
1364 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1368 get_current_regcache ()->cooked_write (realnum
, buf
);
1371 error (_("Attempt to assign to an unmodifiable value."));
1375 /* This function is deprecated. Use get_frame_register_value instead,
1376 which provides more accurate information.
1378 Find and return the value of REGNUM for the specified stack frame.
1379 The number of bytes copied is REGISTER_SIZE (REGNUM).
1381 Returns 0 if the register value could not be found. */
1384 deprecated_frame_register_read (struct frame_info
*frame
, int regnum
,
1389 enum lval_type lval
;
1393 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1394 &lval
, &addr
, &realnum
, myaddr
);
1396 return !optimized
&& !unavailable
;
1400 get_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1401 CORE_ADDR offset
, int len
, gdb_byte
*myaddr
,
1402 int *optimizedp
, int *unavailablep
)
1404 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1409 /* Skip registers wholly inside of OFFSET. */
1410 while (offset
>= register_size (gdbarch
, regnum
))
1412 offset
-= register_size (gdbarch
, regnum
);
1416 /* Ensure that we will not read beyond the end of the register file.
1417 This can only ever happen if the debug information is bad. */
1419 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1420 for (i
= regnum
; i
< numregs
; i
++)
1422 int thissize
= register_size (gdbarch
, i
);
1425 break; /* This register is not available on this architecture. */
1426 maxsize
+= thissize
;
1429 error (_("Bad debug information detected: "
1430 "Attempt to read %d bytes from registers."), len
);
1432 /* Copy the data. */
1435 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1440 if (curr_len
== register_size (gdbarch
, regnum
))
1442 enum lval_type lval
;
1446 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1447 &lval
, &addr
, &realnum
, myaddr
);
1448 if (*optimizedp
|| *unavailablep
)
1453 struct value
*value
= frame_unwind_register_value (frame
->next
,
1455 gdb_assert (value
!= NULL
);
1456 *optimizedp
= value_optimized_out (value
);
1457 *unavailablep
= !value_entirely_available (value
);
1459 if (*optimizedp
|| *unavailablep
)
1461 release_value (value
);
1464 memcpy (myaddr
, value_contents_all (value
) + offset
, curr_len
);
1465 release_value (value
);
1480 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1481 CORE_ADDR offset
, int len
, const gdb_byte
*myaddr
)
1483 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1485 /* Skip registers wholly inside of OFFSET. */
1486 while (offset
>= register_size (gdbarch
, regnum
))
1488 offset
-= register_size (gdbarch
, regnum
);
1492 /* Copy the data. */
1495 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1500 if (curr_len
== register_size (gdbarch
, regnum
))
1502 put_frame_register (frame
, regnum
, myaddr
);
1506 struct value
*value
= frame_unwind_register_value (frame
->next
,
1508 gdb_assert (value
!= NULL
);
1510 memcpy ((char *) value_contents_writeable (value
) + offset
, myaddr
,
1512 put_frame_register (frame
, regnum
, value_contents_raw (value
));
1513 release_value (value
);
1523 /* Create a sentinel frame. */
1525 static struct frame_info
*
1526 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1528 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1531 frame
->pspace
= pspace
;
1532 frame
->aspace
= regcache
->aspace ();
1533 /* Explicitly initialize the sentinel frame's cache. Provide it
1534 with the underlying regcache. In the future additional
1535 information, such as the frame's thread will be added. */
1536 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1537 /* For the moment there is only one sentinel frame implementation. */
1538 frame
->unwind
= &sentinel_frame_unwind
;
1539 /* Link this frame back to itself. The frame is self referential
1540 (the unwound PC is the same as the pc), so make it so. */
1541 frame
->next
= frame
;
1542 /* The sentinel frame has a special ID. */
1543 frame
->this_id
.p
= 1;
1544 frame
->this_id
.value
= sentinel_frame_id
;
1547 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1548 fprint_frame (gdb_stdlog
, frame
);
1549 fprintf_unfiltered (gdb_stdlog
, " }\n");
1554 /* Cache for frame addresses already read by gdb. Valid only while
1555 inferior is stopped. Control variables for the frame cache should
1556 be local to this module. */
1558 static struct obstack frame_cache_obstack
;
1561 frame_obstack_zalloc (unsigned long size
)
1563 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1565 memset (data
, 0, size
);
1569 static struct frame_info
*get_prev_frame_always_1 (struct frame_info
*this_frame
);
1572 get_current_frame (void)
1574 struct frame_info
*current_frame
;
1576 /* First check, and report, the lack of registers. Having GDB
1577 report "No stack!" or "No memory" when the target doesn't even
1578 have registers is very confusing. Besides, "printcmd.exp"
1579 explicitly checks that ``print $pc'' with no registers prints "No
1581 if (!target_has_registers
)
1582 error (_("No registers."));
1583 if (!target_has_stack
)
1584 error (_("No stack."));
1585 if (!target_has_memory
)
1586 error (_("No memory."));
1587 /* Traceframes are effectively a substitute for the live inferior. */
1588 if (get_traceframe_number () < 0)
1589 validate_registers_access ();
1591 if (sentinel_frame
== NULL
)
1593 create_sentinel_frame (current_program_space
, get_current_regcache ());
1595 /* Set the current frame before computing the frame id, to avoid
1596 recursion inside compute_frame_id, in case the frame's
1597 unwinder decides to do a symbol lookup (which depends on the
1598 selected frame's block).
1600 This call must always succeed. In particular, nothing inside
1601 get_prev_frame_always_1 should try to unwind from the
1602 sentinel frame, because that could fail/throw, and we always
1603 want to leave with the current frame created and linked in --
1604 we should never end up with the sentinel frame as outermost
1606 current_frame
= get_prev_frame_always_1 (sentinel_frame
);
1607 gdb_assert (current_frame
!= NULL
);
1609 return current_frame
;
1612 /* The "selected" stack frame is used by default for local and arg
1613 access. May be zero, for no selected frame. */
1615 static struct frame_info
*selected_frame
;
1618 has_stack_frames (void)
1620 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
1623 /* Traceframes are effectively a substitute for the live inferior. */
1624 if (get_traceframe_number () < 0)
1626 /* No current inferior, no frame. */
1627 if (ptid_equal (inferior_ptid
, null_ptid
))
1630 /* Don't try to read from a dead thread. */
1631 if (is_exited (inferior_ptid
))
1634 /* ... or from a spinning thread. */
1635 if (is_executing (inferior_ptid
))
1642 /* Return the selected frame. Always non-NULL (unless there isn't an
1643 inferior sufficient for creating a frame) in which case an error is
1647 get_selected_frame (const char *message
)
1649 if (selected_frame
== NULL
)
1651 if (message
!= NULL
&& !has_stack_frames ())
1652 error (("%s"), message
);
1653 /* Hey! Don't trust this. It should really be re-finding the
1654 last selected frame of the currently selected thread. This,
1655 though, is better than nothing. */
1656 select_frame (get_current_frame ());
1658 /* There is always a frame. */
1659 gdb_assert (selected_frame
!= NULL
);
1660 return selected_frame
;
1663 /* If there is a selected frame, return it. Otherwise, return NULL. */
1666 get_selected_frame_if_set (void)
1668 return selected_frame
;
1671 /* This is a variant of get_selected_frame() which can be called when
1672 the inferior does not have a frame; in that case it will return
1673 NULL instead of calling error(). */
1676 deprecated_safe_get_selected_frame (void)
1678 if (!has_stack_frames ())
1680 return get_selected_frame (NULL
);
1683 /* Select frame FI (or NULL - to invalidate the current frame). */
1686 select_frame (struct frame_info
*fi
)
1688 selected_frame
= fi
;
1689 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1690 frame is being invalidated. */
1692 /* FIXME: kseitz/2002-08-28: It would be nice to call
1693 selected_frame_level_changed_event() right here, but due to limitations
1694 in the current interfaces, we would end up flooding UIs with events
1695 because select_frame() is used extensively internally.
1697 Once we have frame-parameterized frame (and frame-related) commands,
1698 the event notification can be moved here, since this function will only
1699 be called when the user's selected frame is being changed. */
1701 /* Ensure that symbols for this frame are read in. Also, determine the
1702 source language of this frame, and switch to it if desired. */
1707 /* We retrieve the frame's symtab by using the frame PC.
1708 However we cannot use the frame PC as-is, because it usually
1709 points to the instruction following the "call", which is
1710 sometimes the first instruction of another function. So we
1711 rely on get_frame_address_in_block() which provides us with a
1712 PC which is guaranteed to be inside the frame's code
1714 if (get_frame_address_in_block_if_available (fi
, &pc
))
1716 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1719 && compunit_language (cust
) != current_language
->la_language
1720 && compunit_language (cust
) != language_unknown
1721 && language_mode
== language_mode_auto
)
1722 set_language (compunit_language (cust
));
1727 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1728 Always returns a non-NULL value. */
1731 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1733 struct frame_info
*fi
;
1737 fprintf_unfiltered (gdb_stdlog
,
1738 "{ create_new_frame (addr=%s, pc=%s) ",
1739 hex_string (addr
), hex_string (pc
));
1742 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1744 fi
->next
= create_sentinel_frame (current_program_space
,
1745 get_current_regcache ());
1747 /* Set/update this frame's cached PC value, found in the next frame.
1748 Do this before looking for this frame's unwinder. A sniffer is
1749 very likely to read this, and the corresponding unwinder is
1750 entitled to rely that the PC doesn't magically change. */
1751 fi
->next
->prev_pc
.value
= pc
;
1752 fi
->next
->prev_pc
.status
= CC_VALUE
;
1754 /* We currently assume that frame chain's can't cross spaces. */
1755 fi
->pspace
= fi
->next
->pspace
;
1756 fi
->aspace
= fi
->next
->aspace
;
1758 /* Select/initialize both the unwind function and the frame's type
1760 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1763 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1767 fprintf_unfiltered (gdb_stdlog
, "-> ");
1768 fprint_frame (gdb_stdlog
, fi
);
1769 fprintf_unfiltered (gdb_stdlog
, " }\n");
1775 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1776 innermost frame). Be careful to not fall off the bottom of the
1777 frame chain and onto the sentinel frame. */
1780 get_next_frame (struct frame_info
*this_frame
)
1782 if (this_frame
->level
> 0)
1783 return this_frame
->next
;
1788 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
1789 innermost (i.e. current) frame, return the sentinel frame. Thus,
1790 unlike get_next_frame(), NULL will never be returned. */
1793 get_next_frame_sentinel_okay (struct frame_info
*this_frame
)
1795 gdb_assert (this_frame
!= NULL
);
1797 /* Note that, due to the manner in which the sentinel frame is
1798 constructed, this_frame->next still works even when this_frame
1799 is the sentinel frame. But we disallow it here anyway because
1800 calling get_next_frame_sentinel_okay() on the sentinel frame
1801 is likely a coding error. */
1802 gdb_assert (this_frame
!= sentinel_frame
);
1804 return this_frame
->next
;
1807 /* Observer for the target_changed event. */
1810 frame_observer_target_changed (struct target_ops
*target
)
1812 reinit_frame_cache ();
1815 /* Flush the entire frame cache. */
1818 reinit_frame_cache (void)
1820 struct frame_info
*fi
;
1822 /* Tear down all frame caches. */
1823 for (fi
= sentinel_frame
; fi
!= NULL
; fi
= fi
->prev
)
1825 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
1826 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
1827 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
1828 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
1831 /* Since we can't really be sure what the first object allocated was. */
1832 obstack_free (&frame_cache_obstack
, 0);
1833 obstack_init (&frame_cache_obstack
);
1835 if (sentinel_frame
!= NULL
)
1836 annotate_frames_invalid ();
1838 sentinel_frame
= NULL
; /* Invalidate cache */
1839 select_frame (NULL
);
1840 frame_stash_invalidate ();
1842 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
1845 /* Find where a register is saved (in memory or another register).
1846 The result of frame_register_unwind is just where it is saved
1847 relative to this particular frame. */
1850 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
1851 int *optimizedp
, enum lval_type
*lvalp
,
1852 CORE_ADDR
*addrp
, int *realnump
)
1854 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
1856 while (this_frame
!= NULL
)
1860 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
1861 lvalp
, addrp
, realnump
, NULL
);
1866 if (*lvalp
!= lval_register
)
1870 this_frame
= get_next_frame (this_frame
);
1874 /* Get the previous raw frame, and check that it is not identical to
1875 same other frame frame already in the chain. If it is, there is
1876 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1877 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
1878 validity tests, that compare THIS_FRAME and the next frame, we do
1879 this right after creating the previous frame, to avoid ever ending
1880 up with two frames with the same id in the frame chain. */
1882 static struct frame_info
*
1883 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
1885 struct frame_info
*prev_frame
;
1887 prev_frame
= get_prev_frame_raw (this_frame
);
1889 /* Don't compute the frame id of the current frame yet. Unwinding
1890 the sentinel frame can fail (e.g., if the thread is gone and we
1891 can't thus read its registers). If we let the cycle detection
1892 code below try to compute a frame ID, then an error thrown from
1893 within the frame ID computation would result in the sentinel
1894 frame as outermost frame, which is bogus. Instead, we'll compute
1895 the current frame's ID lazily in get_frame_id. Note that there's
1896 no point in doing cycle detection when there's only one frame, so
1897 nothing is lost here. */
1898 if (prev_frame
->level
== 0)
1903 compute_frame_id (prev_frame
);
1904 if (!frame_stash_add (prev_frame
))
1906 /* Another frame with the same id was already in the stash. We just
1907 detected a cycle. */
1910 fprintf_unfiltered (gdb_stdlog
, "-> ");
1911 fprint_frame (gdb_stdlog
, NULL
);
1912 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
1914 this_frame
->stop_reason
= UNWIND_SAME_ID
;
1916 prev_frame
->next
= NULL
;
1917 this_frame
->prev
= NULL
;
1921 CATCH (ex
, RETURN_MASK_ALL
)
1923 prev_frame
->next
= NULL
;
1924 this_frame
->prev
= NULL
;
1926 throw_exception (ex
);
1933 /* Helper function for get_prev_frame_always, this is called inside a
1934 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
1935 there is no such frame. This may throw an exception. */
1937 static struct frame_info
*
1938 get_prev_frame_always_1 (struct frame_info
*this_frame
)
1940 struct gdbarch
*gdbarch
;
1942 gdb_assert (this_frame
!= NULL
);
1943 gdbarch
= get_frame_arch (this_frame
);
1947 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
1948 if (this_frame
!= NULL
)
1949 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1951 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1952 fprintf_unfiltered (gdb_stdlog
, ") ");
1955 /* Only try to do the unwind once. */
1956 if (this_frame
->prev_p
)
1960 fprintf_unfiltered (gdb_stdlog
, "-> ");
1961 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1962 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1964 return this_frame
->prev
;
1967 /* If the frame unwinder hasn't been selected yet, we must do so
1968 before setting prev_p; otherwise the check for misbehaved
1969 sniffers will think that this frame's sniffer tried to unwind
1970 further (see frame_cleanup_after_sniffer). */
1971 if (this_frame
->unwind
== NULL
)
1972 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
1974 this_frame
->prev_p
= 1;
1975 this_frame
->stop_reason
= UNWIND_NO_REASON
;
1977 /* If we are unwinding from an inline frame, all of the below tests
1978 were already performed when we unwound from the next non-inline
1979 frame. We must skip them, since we can not get THIS_FRAME's ID
1980 until we have unwound all the way down to the previous non-inline
1982 if (get_frame_type (this_frame
) == INLINE_FRAME
)
1983 return get_prev_frame_if_no_cycle (this_frame
);
1985 /* Check that this frame is unwindable. If it isn't, don't try to
1986 unwind to the prev frame. */
1987 this_frame
->stop_reason
1988 = this_frame
->unwind
->stop_reason (this_frame
,
1989 &this_frame
->prologue_cache
);
1991 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
1995 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
1997 fprintf_unfiltered (gdb_stdlog
, "-> ");
1998 fprint_frame (gdb_stdlog
, NULL
);
1999 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
2000 frame_stop_reason_symbol_string (reason
));
2005 /* Check that this frame's ID isn't inner to (younger, below, next)
2006 the next frame. This happens when a frame unwind goes backwards.
2007 This check is valid only if this frame and the next frame are NORMAL.
2008 See the comment at frame_id_inner for details. */
2009 if (get_frame_type (this_frame
) == NORMAL_FRAME
2010 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2011 && frame_id_inner (get_frame_arch (this_frame
->next
),
2012 get_frame_id (this_frame
),
2013 get_frame_id (this_frame
->next
)))
2015 CORE_ADDR this_pc_in_block
;
2016 struct minimal_symbol
*morestack_msym
;
2017 const char *morestack_name
= NULL
;
2019 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2020 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2021 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2023 morestack_name
= MSYMBOL_LINKAGE_NAME (morestack_msym
);
2024 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2028 fprintf_unfiltered (gdb_stdlog
, "-> ");
2029 fprint_frame (gdb_stdlog
, NULL
);
2030 fprintf_unfiltered (gdb_stdlog
,
2031 " // this frame ID is inner }\n");
2033 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2038 /* Check that this and the next frame do not unwind the PC register
2039 to the same memory location. If they do, then even though they
2040 have different frame IDs, the new frame will be bogus; two
2041 functions can't share a register save slot for the PC. This can
2042 happen when the prologue analyzer finds a stack adjustment, but
2045 This check does assume that the "PC register" is roughly a
2046 traditional PC, even if the gdbarch_unwind_pc method adjusts
2047 it (we do not rely on the value, only on the unwound PC being
2048 dependent on this value). A potential improvement would be
2049 to have the frame prev_pc method and the gdbarch unwind_pc
2050 method set the same lval and location information as
2051 frame_register_unwind. */
2052 if (this_frame
->level
> 0
2053 && gdbarch_pc_regnum (gdbarch
) >= 0
2054 && get_frame_type (this_frame
) == NORMAL_FRAME
2055 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
2056 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
2058 int optimized
, realnum
, nrealnum
;
2059 enum lval_type lval
, nlval
;
2060 CORE_ADDR addr
, naddr
;
2062 frame_register_unwind_location (this_frame
,
2063 gdbarch_pc_regnum (gdbarch
),
2064 &optimized
, &lval
, &addr
, &realnum
);
2065 frame_register_unwind_location (get_next_frame (this_frame
),
2066 gdbarch_pc_regnum (gdbarch
),
2067 &optimized
, &nlval
, &naddr
, &nrealnum
);
2069 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2070 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2074 fprintf_unfiltered (gdb_stdlog
, "-> ");
2075 fprint_frame (gdb_stdlog
, NULL
);
2076 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
2079 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2080 this_frame
->prev
= NULL
;
2085 return get_prev_frame_if_no_cycle (this_frame
);
2088 /* Return a "struct frame_info" corresponding to the frame that called
2089 THIS_FRAME. Returns NULL if there is no such frame.
2091 Unlike get_prev_frame, this function always tries to unwind the
2095 get_prev_frame_always (struct frame_info
*this_frame
)
2097 struct frame_info
*prev_frame
= NULL
;
2101 prev_frame
= get_prev_frame_always_1 (this_frame
);
2103 CATCH (ex
, RETURN_MASK_ERROR
)
2105 if (ex
.error
== MEMORY_ERROR
)
2107 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2108 if (ex
.message
!= NULL
)
2113 /* The error needs to live as long as the frame does.
2114 Allocate using stack local STOP_STRING then assign the
2115 pointer to the frame, this allows the STOP_STRING on the
2116 frame to be of type 'const char *'. */
2117 size
= strlen (ex
.message
) + 1;
2118 stop_string
= (char *) frame_obstack_zalloc (size
);
2119 memcpy (stop_string
, ex
.message
, size
);
2120 this_frame
->stop_string
= stop_string
;
2125 throw_exception (ex
);
2132 /* Construct a new "struct frame_info" and link it previous to
2135 static struct frame_info
*
2136 get_prev_frame_raw (struct frame_info
*this_frame
)
2138 struct frame_info
*prev_frame
;
2140 /* Allocate the new frame but do not wire it in to the frame chain.
2141 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2142 frame->next to pull some fancy tricks (of course such code is, by
2143 definition, recursive). Try to prevent it.
2145 There is no reason to worry about memory leaks, should the
2146 remainder of the function fail. The allocated memory will be
2147 quickly reclaimed when the frame cache is flushed, and the `we've
2148 been here before' check above will stop repeated memory
2149 allocation calls. */
2150 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2151 prev_frame
->level
= this_frame
->level
+ 1;
2153 /* For now, assume we don't have frame chains crossing address
2155 prev_frame
->pspace
= this_frame
->pspace
;
2156 prev_frame
->aspace
= this_frame
->aspace
;
2158 /* Don't yet compute ->unwind (and hence ->type). It is computed
2159 on-demand in get_frame_type, frame_register_unwind, and
2162 /* Don't yet compute the frame's ID. It is computed on-demand by
2165 /* The unwound frame ID is validate at the start of this function,
2166 as part of the logic to decide if that frame should be further
2167 unwound, and not here while the prev frame is being created.
2168 Doing this makes it possible for the user to examine a frame that
2169 has an invalid frame ID.
2171 Some very old VAX code noted: [...] For the sake of argument,
2172 suppose that the stack is somewhat trashed (which is one reason
2173 that "info frame" exists). So, return 0 (indicating we don't
2174 know the address of the arglist) if we don't know what frame this
2178 this_frame
->prev
= prev_frame
;
2179 prev_frame
->next
= this_frame
;
2183 fprintf_unfiltered (gdb_stdlog
, "-> ");
2184 fprint_frame (gdb_stdlog
, prev_frame
);
2185 fprintf_unfiltered (gdb_stdlog
, " }\n");
2191 /* Debug routine to print a NULL frame being returned. */
2194 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2199 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2200 if (this_frame
!= NULL
)
2201 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2203 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2204 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2208 /* Is this (non-sentinel) frame in the "main"() function? */
2211 inside_main_func (struct frame_info
*this_frame
)
2213 struct bound_minimal_symbol msymbol
;
2216 if (symfile_objfile
== 0)
2218 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
2219 if (msymbol
.minsym
== NULL
)
2221 /* Make certain that the code, and not descriptor, address is
2223 maddr
= gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame
),
2224 BMSYMBOL_VALUE_ADDRESS (msymbol
),
2226 return maddr
== get_frame_func (this_frame
);
2229 /* Test whether THIS_FRAME is inside the process entry point function. */
2232 inside_entry_func (struct frame_info
*this_frame
)
2234 CORE_ADDR entry_point
;
2236 if (!entry_point_address_query (&entry_point
))
2239 return get_frame_func (this_frame
) == entry_point
;
2242 /* Return a structure containing various interesting information about
2243 the frame that called THIS_FRAME. Returns NULL if there is entier
2244 no such frame or the frame fails any of a set of target-independent
2245 condition that should terminate the frame chain (e.g., as unwinding
2248 This function should not contain target-dependent tests, such as
2249 checking whether the program-counter is zero. */
2252 get_prev_frame (struct frame_info
*this_frame
)
2257 /* There is always a frame. If this assertion fails, suspect that
2258 something should be calling get_selected_frame() or
2259 get_current_frame(). */
2260 gdb_assert (this_frame
!= NULL
);
2262 /* If this_frame is the current frame, then compute and stash
2263 its frame id prior to fetching and computing the frame id of the
2264 previous frame. Otherwise, the cycle detection code in
2265 get_prev_frame_if_no_cycle() will not work correctly. When
2266 get_frame_id() is called later on, an assertion error will
2267 be triggered in the event of a cycle between the current
2268 frame and its previous frame. */
2269 if (this_frame
->level
== 0)
2270 get_frame_id (this_frame
);
2272 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2274 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2275 sense to stop unwinding at a dummy frame. One place where a dummy
2276 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2277 pcsqh register (space register for the instruction at the head of the
2278 instruction queue) cannot be written directly; the only way to set it
2279 is to branch to code that is in the target space. In order to implement
2280 frame dummies on HPUX, the called function is made to jump back to where
2281 the inferior was when the user function was called. If gdb was inside
2282 the main function when we created the dummy frame, the dummy frame will
2283 point inside the main function. */
2284 if (this_frame
->level
>= 0
2285 && get_frame_type (this_frame
) == NORMAL_FRAME
2286 && !backtrace_past_main
2288 && inside_main_func (this_frame
))
2289 /* Don't unwind past main(). Note, this is done _before_ the
2290 frame has been marked as previously unwound. That way if the
2291 user later decides to enable unwinds past main(), that will
2292 automatically happen. */
2294 frame_debug_got_null_frame (this_frame
, "inside main func");
2298 /* If the user's backtrace limit has been exceeded, stop. We must
2299 add two to the current level; one of those accounts for backtrace_limit
2300 being 1-based and the level being 0-based, and the other accounts for
2301 the level of the new frame instead of the level of the current
2303 if (this_frame
->level
+ 2 > backtrace_limit
)
2305 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2309 /* If we're already inside the entry function for the main objfile,
2310 then it isn't valid. Don't apply this test to a dummy frame -
2311 dummy frame PCs typically land in the entry func. Don't apply
2312 this test to the sentinel frame. Sentinel frames should always
2313 be allowed to unwind. */
2314 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2315 wasn't checking for "main" in the minimal symbols. With that
2316 fixed asm-source tests now stop in "main" instead of halting the
2317 backtrace in weird and wonderful ways somewhere inside the entry
2318 file. Suspect that tests for inside the entry file/func were
2319 added to work around that (now fixed) case. */
2320 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2321 suggested having the inside_entry_func test use the
2322 inside_main_func() msymbol trick (along with entry_point_address()
2323 I guess) to determine the address range of the start function.
2324 That should provide a far better stopper than the current
2326 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2327 applied tail-call optimizations to main so that a function called
2328 from main returns directly to the caller of main. Since we don't
2329 stop at main, we should at least stop at the entry point of the
2331 if (this_frame
->level
>= 0
2332 && get_frame_type (this_frame
) == NORMAL_FRAME
2333 && !backtrace_past_entry
2335 && inside_entry_func (this_frame
))
2337 frame_debug_got_null_frame (this_frame
, "inside entry func");
2341 /* Assume that the only way to get a zero PC is through something
2342 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2343 will never unwind a zero PC. */
2344 if (this_frame
->level
> 0
2345 && (get_frame_type (this_frame
) == NORMAL_FRAME
2346 || get_frame_type (this_frame
) == INLINE_FRAME
)
2347 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2348 && frame_pc_p
&& frame_pc
== 0)
2350 frame_debug_got_null_frame (this_frame
, "zero PC");
2354 return get_prev_frame_always (this_frame
);
2358 get_prev_frame_id_by_id (struct frame_id id
)
2360 struct frame_id prev_id
;
2361 struct frame_info
*frame
;
2363 frame
= frame_find_by_id (id
);
2366 prev_id
= get_frame_id (get_prev_frame (frame
));
2368 prev_id
= null_frame_id
;
2374 get_frame_pc (struct frame_info
*frame
)
2376 gdb_assert (frame
->next
!= NULL
);
2377 return frame_unwind_pc (frame
->next
);
2381 get_frame_pc_if_available (struct frame_info
*frame
, CORE_ADDR
*pc
)
2384 gdb_assert (frame
->next
!= NULL
);
2388 *pc
= frame_unwind_pc (frame
->next
);
2390 CATCH (ex
, RETURN_MASK_ERROR
)
2392 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2395 throw_exception (ex
);
2402 /* Return an address that falls within THIS_FRAME's code block. */
2405 get_frame_address_in_block (struct frame_info
*this_frame
)
2407 /* A draft address. */
2408 CORE_ADDR pc
= get_frame_pc (this_frame
);
2410 struct frame_info
*next_frame
= this_frame
->next
;
2412 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2413 Normally the resume address is inside the body of the function
2414 associated with THIS_FRAME, but there is a special case: when
2415 calling a function which the compiler knows will never return
2416 (for instance abort), the call may be the very last instruction
2417 in the calling function. The resume address will point after the
2418 call and may be at the beginning of a different function
2421 If THIS_FRAME is a signal frame or dummy frame, then we should
2422 not adjust the unwound PC. For a dummy frame, GDB pushed the
2423 resume address manually onto the stack. For a signal frame, the
2424 OS may have pushed the resume address manually and invoked the
2425 handler (e.g. GNU/Linux), or invoked the trampoline which called
2426 the signal handler - but in either case the signal handler is
2427 expected to return to the trampoline. So in both of these
2428 cases we know that the resume address is executable and
2429 related. So we only need to adjust the PC if THIS_FRAME
2430 is a normal function.
2432 If the program has been interrupted while THIS_FRAME is current,
2433 then clearly the resume address is inside the associated
2434 function. There are three kinds of interruption: debugger stop
2435 (next frame will be SENTINEL_FRAME), operating system
2436 signal or exception (next frame will be SIGTRAMP_FRAME),
2437 or debugger-induced function call (next frame will be
2438 DUMMY_FRAME). So we only need to adjust the PC if
2439 NEXT_FRAME is a normal function.
2441 We check the type of NEXT_FRAME first, since it is already
2442 known; frame type is determined by the unwinder, and since
2443 we have THIS_FRAME we've already selected an unwinder for
2446 If the next frame is inlined, we need to keep going until we find
2447 the real function - for instance, if a signal handler is invoked
2448 while in an inlined function, then the code address of the
2449 "calling" normal function should not be adjusted either. */
2451 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2452 next_frame
= next_frame
->next
;
2454 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2455 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2456 && (get_frame_type (this_frame
) == NORMAL_FRAME
2457 || get_frame_type (this_frame
) == TAILCALL_FRAME
2458 || get_frame_type (this_frame
) == INLINE_FRAME
))
2465 get_frame_address_in_block_if_available (struct frame_info
*this_frame
,
2471 *pc
= get_frame_address_in_block (this_frame
);
2473 CATCH (ex
, RETURN_MASK_ERROR
)
2475 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2477 throw_exception (ex
);
2485 find_frame_sal (frame_info
*frame
)
2487 struct frame_info
*next_frame
;
2491 /* If the next frame represents an inlined function call, this frame's
2492 sal is the "call site" of that inlined function, which can not
2493 be inferred from get_frame_pc. */
2494 next_frame
= get_next_frame (frame
);
2495 if (frame_inlined_callees (frame
) > 0)
2500 sym
= get_frame_function (next_frame
);
2502 sym
= inline_skipped_symbol (inferior_ptid
);
2504 /* If frame is inline, it certainly has symbols. */
2507 symtab_and_line sal
;
2508 if (SYMBOL_LINE (sym
) != 0)
2510 sal
.symtab
= symbol_symtab (sym
);
2511 sal
.line
= SYMBOL_LINE (sym
);
2514 /* If the symbol does not have a location, we don't know where
2515 the call site is. Do not pretend to. This is jarring, but
2516 we can't do much better. */
2517 sal
.pc
= get_frame_pc (frame
);
2519 sal
.pspace
= get_frame_program_space (frame
);
2523 /* If FRAME is not the innermost frame, that normally means that
2524 FRAME->pc points at the return instruction (which is *after* the
2525 call instruction), and we want to get the line containing the
2526 call (because the call is where the user thinks the program is).
2527 However, if the next frame is either a SIGTRAMP_FRAME or a
2528 DUMMY_FRAME, then the next frame will contain a saved interrupt
2529 PC and such a PC indicates the current (rather than next)
2530 instruction/line, consequently, for such cases, want to get the
2531 line containing fi->pc. */
2532 if (!get_frame_pc_if_available (frame
, &pc
))
2535 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2536 return find_pc_line (pc
, notcurrent
);
2539 /* Per "frame.h", return the ``address'' of the frame. Code should
2540 really be using get_frame_id(). */
2542 get_frame_base (struct frame_info
*fi
)
2544 return get_frame_id (fi
).stack_addr
;
2547 /* High-level offsets into the frame. Used by the debug info. */
2550 get_frame_base_address (struct frame_info
*fi
)
2552 if (get_frame_type (fi
) != NORMAL_FRAME
)
2554 if (fi
->base
== NULL
)
2555 fi
->base
= frame_base_find_by_frame (fi
);
2556 /* Sneaky: If the low-level unwind and high-level base code share a
2557 common unwinder, let them share the prologue cache. */
2558 if (fi
->base
->unwind
== fi
->unwind
)
2559 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2560 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2564 get_frame_locals_address (struct frame_info
*fi
)
2566 if (get_frame_type (fi
) != NORMAL_FRAME
)
2568 /* If there isn't a frame address method, find it. */
2569 if (fi
->base
== NULL
)
2570 fi
->base
= frame_base_find_by_frame (fi
);
2571 /* Sneaky: If the low-level unwind and high-level base code share a
2572 common unwinder, let them share the prologue cache. */
2573 if (fi
->base
->unwind
== fi
->unwind
)
2574 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2575 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2579 get_frame_args_address (struct frame_info
*fi
)
2581 if (get_frame_type (fi
) != NORMAL_FRAME
)
2583 /* If there isn't a frame address method, find it. */
2584 if (fi
->base
== NULL
)
2585 fi
->base
= frame_base_find_by_frame (fi
);
2586 /* Sneaky: If the low-level unwind and high-level base code share a
2587 common unwinder, let them share the prologue cache. */
2588 if (fi
->base
->unwind
== fi
->unwind
)
2589 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2590 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2593 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2597 frame_unwinder_is (struct frame_info
*fi
, const struct frame_unwind
*unwinder
)
2599 if (fi
->unwind
== NULL
)
2600 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2601 return fi
->unwind
== unwinder
;
2604 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2605 or -1 for a NULL frame. */
2608 frame_relative_level (struct frame_info
*fi
)
2617 get_frame_type (struct frame_info
*frame
)
2619 if (frame
->unwind
== NULL
)
2620 /* Initialize the frame's unwinder because that's what
2621 provides the frame's type. */
2622 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2623 return frame
->unwind
->type
;
2626 struct program_space
*
2627 get_frame_program_space (struct frame_info
*frame
)
2629 return frame
->pspace
;
2632 struct program_space
*
2633 frame_unwind_program_space (struct frame_info
*this_frame
)
2635 gdb_assert (this_frame
);
2637 /* This is really a placeholder to keep the API consistent --- we
2638 assume for now that we don't have frame chains crossing
2640 return this_frame
->pspace
;
2643 const address_space
*
2644 get_frame_address_space (struct frame_info
*frame
)
2646 return frame
->aspace
;
2649 /* Memory access methods. */
2652 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2653 gdb_byte
*buf
, int len
)
2655 read_memory (addr
, buf
, len
);
2659 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2662 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2663 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2665 return read_memory_integer (addr
, len
, byte_order
);
2669 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2672 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2673 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2675 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2679 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2680 CORE_ADDR addr
, gdb_byte
*buf
, int len
)
2682 /* NOTE: target_read_memory returns zero on success! */
2683 return !target_read_memory (addr
, buf
, len
);
2686 /* Architecture methods. */
2689 get_frame_arch (struct frame_info
*this_frame
)
2691 return frame_unwind_arch (this_frame
->next
);
2695 frame_unwind_arch (struct frame_info
*next_frame
)
2697 if (!next_frame
->prev_arch
.p
)
2699 struct gdbarch
*arch
;
2701 if (next_frame
->unwind
== NULL
)
2702 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2704 if (next_frame
->unwind
->prev_arch
!= NULL
)
2705 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2706 &next_frame
->prologue_cache
);
2708 arch
= get_frame_arch (next_frame
);
2710 next_frame
->prev_arch
.arch
= arch
;
2711 next_frame
->prev_arch
.p
= 1;
2713 fprintf_unfiltered (gdb_stdlog
,
2714 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2716 gdbarch_bfd_arch_info (arch
)->printable_name
);
2719 return next_frame
->prev_arch
.arch
;
2723 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2725 next_frame
= skip_artificial_frames (next_frame
);
2727 /* We must have a non-artificial frame. The caller is supposed to check
2728 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2730 gdb_assert (next_frame
!= NULL
);
2732 return frame_unwind_arch (next_frame
);
2735 /* Gets the language of FRAME. */
2738 get_frame_language (struct frame_info
*frame
)
2743 gdb_assert (frame
!= NULL
);
2745 /* We determine the current frame language by looking up its
2746 associated symtab. To retrieve this symtab, we use the frame
2747 PC. However we cannot use the frame PC as is, because it
2748 usually points to the instruction following the "call", which
2749 is sometimes the first instruction of another function. So
2750 we rely on get_frame_address_in_block(), it provides us with
2751 a PC that is guaranteed to be inside the frame's code
2756 pc
= get_frame_address_in_block (frame
);
2759 CATCH (ex
, RETURN_MASK_ERROR
)
2761 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2762 throw_exception (ex
);
2768 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
2771 return compunit_language (cust
);
2774 return language_unknown
;
2777 /* Stack pointer methods. */
2780 get_frame_sp (struct frame_info
*this_frame
)
2782 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2784 /* Normality - an architecture that provides a way of obtaining any
2785 frame inner-most address. */
2786 if (gdbarch_unwind_sp_p (gdbarch
))
2787 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2788 operate on THIS_FRAME now. */
2789 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
2790 /* Now things are really are grim. Hope that the value returned by
2791 the gdbarch_sp_regnum register is meaningful. */
2792 if (gdbarch_sp_regnum (gdbarch
) >= 0)
2793 return get_frame_register_unsigned (this_frame
,
2794 gdbarch_sp_regnum (gdbarch
));
2795 internal_error (__FILE__
, __LINE__
, _("Missing unwind SP method"));
2798 /* Return the reason why we can't unwind past FRAME. */
2800 enum unwind_stop_reason
2801 get_frame_unwind_stop_reason (struct frame_info
*frame
)
2803 /* Fill-in STOP_REASON. */
2804 get_prev_frame_always (frame
);
2805 gdb_assert (frame
->prev_p
);
2807 return frame
->stop_reason
;
2810 /* Return a string explaining REASON. */
2813 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
2817 #define SET(name, description) \
2818 case name: return _(description);
2819 #include "unwind_stop_reasons.def"
2823 internal_error (__FILE__
, __LINE__
,
2824 "Invalid frame stop reason");
2829 frame_stop_reason_string (struct frame_info
*fi
)
2831 gdb_assert (fi
->prev_p
);
2832 gdb_assert (fi
->prev
== NULL
);
2834 /* Return the specific string if we have one. */
2835 if (fi
->stop_string
!= NULL
)
2836 return fi
->stop_string
;
2838 /* Return the generic string if we have nothing better. */
2839 return unwind_stop_reason_to_string (fi
->stop_reason
);
2842 /* Return the enum symbol name of REASON as a string, to use in debug
2846 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
2850 #define SET(name, description) \
2851 case name: return #name;
2852 #include "unwind_stop_reasons.def"
2856 internal_error (__FILE__
, __LINE__
,
2857 "Invalid frame stop reason");
2861 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2865 frame_cleanup_after_sniffer (struct frame_info
*frame
)
2867 /* The sniffer should not allocate a prologue cache if it did not
2868 match this frame. */
2869 gdb_assert (frame
->prologue_cache
== NULL
);
2871 /* No sniffer should extend the frame chain; sniff based on what is
2873 gdb_assert (!frame
->prev_p
);
2875 /* The sniffer should not check the frame's ID; that's circular. */
2876 gdb_assert (!frame
->this_id
.p
);
2878 /* Clear cached fields dependent on the unwinder.
2880 The previous PC is independent of the unwinder, but the previous
2881 function is not (see get_frame_address_in_block). */
2882 frame
->prev_func
.p
= 0;
2883 frame
->prev_func
.addr
= 0;
2885 /* Discard the unwinder last, so that we can easily find it if an assertion
2886 in this function triggers. */
2887 frame
->unwind
= NULL
;
2890 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2891 If sniffing fails, the caller should be sure to call
2892 frame_cleanup_after_sniffer. */
2895 frame_prepare_for_sniffer (struct frame_info
*frame
,
2896 const struct frame_unwind
*unwind
)
2898 gdb_assert (frame
->unwind
== NULL
);
2899 frame
->unwind
= unwind
;
2902 static struct cmd_list_element
*set_backtrace_cmdlist
;
2903 static struct cmd_list_element
*show_backtrace_cmdlist
;
2906 set_backtrace_cmd (const char *args
, int from_tty
)
2908 help_list (set_backtrace_cmdlist
, "set backtrace ", all_commands
,
2913 show_backtrace_cmd (const char *args
, int from_tty
)
2915 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2919 _initialize_frame (void)
2921 obstack_init (&frame_cache_obstack
);
2923 frame_stash_create ();
2925 gdb::observers::target_changed
.attach (frame_observer_target_changed
);
2927 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, _("\
2928 Set backtrace specific variables.\n\
2929 Configure backtrace variables such as the backtrace limit"),
2930 &set_backtrace_cmdlist
, "set backtrace ",
2931 0/*allow-unknown*/, &setlist
);
2932 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, _("\
2933 Show backtrace specific variables\n\
2934 Show backtrace variables such as the backtrace limit"),
2935 &show_backtrace_cmdlist
, "show backtrace ",
2936 0/*allow-unknown*/, &showlist
);
2938 add_setshow_boolean_cmd ("past-main", class_obscure
,
2939 &backtrace_past_main
, _("\
2940 Set whether backtraces should continue past \"main\"."), _("\
2941 Show whether backtraces should continue past \"main\"."), _("\
2942 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2943 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2944 of the stack trace."),
2946 show_backtrace_past_main
,
2947 &set_backtrace_cmdlist
,
2948 &show_backtrace_cmdlist
);
2950 add_setshow_boolean_cmd ("past-entry", class_obscure
,
2951 &backtrace_past_entry
, _("\
2952 Set whether backtraces should continue past the entry point of a program."),
2954 Show whether backtraces should continue past the entry point of a program."),
2956 Normally there are no callers beyond the entry point of a program, so GDB\n\
2957 will terminate the backtrace there. Set this variable if you need to see\n\
2958 the rest of the stack trace."),
2960 show_backtrace_past_entry
,
2961 &set_backtrace_cmdlist
,
2962 &show_backtrace_cmdlist
);
2964 add_setshow_uinteger_cmd ("limit", class_obscure
,
2965 &backtrace_limit
, _("\
2966 Set an upper bound on the number of backtrace levels."), _("\
2967 Show the upper bound on the number of backtrace levels."), _("\
2968 No more than the specified number of frames can be displayed or examined.\n\
2969 Literal \"unlimited\" or zero means no limit."),
2971 show_backtrace_limit
,
2972 &set_backtrace_cmdlist
,
2973 &show_backtrace_cmdlist
);
2975 /* Debug this files internals. */
2976 add_setshow_zuinteger_cmd ("frame", class_maintenance
, &frame_debug
, _("\
2977 Set frame debugging."), _("\
2978 Show frame debugging."), _("\
2979 When non-zero, frame specific internal debugging is enabled."),
2982 &setdebuglist
, &showdebuglist
);